text: /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  //
  // TGUI - Texus's Graphical User Interface
  // Copyright (C) 2012-2015 Bruno Van de Velde (vdv_b@tgui.eu)
  //
  // This software is provided 'as-is', without any express or implied warranty.
  // In no event will the authors be held liable for any damages arising from the use of this software.
  //
  // Permission is granted to anyone to use this software for any purpose,
  // including commercial applications, and to alter it and redistribute it freely,
  // subject to the following restrictions:
  //
  // 1. The origin of this software must not be misrepresented;
  //    you must not claim that you wrote the original software.
  //    If you use this software in a product, an acknowledgment
  //    in the product documentation would be appreciated but is not required.
  //
  // 2. Altered source versions must be plainly marked as such,
  //    and must not be misrepresented as being the original software.
  //
  // 3. This notice may not be removed or altered from any source distribution.
  //
  /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  
  #ifndef TGUI_TEXT_BOX_HPP
  #define TGUI_TEXT_BOX_HPP
  
  
  #include <TGUI/Widget.hpp>
  
  /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  namespace tgui
  {
      class Scrollbar;
      class TextBoxRenderer;
  
      /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
      /// @brief Text box widget
      ///
      /// Signals:
      ///     - TextChanged
      ///         * Optional parameter sf::String: current text in the text box
      ///         * Uses Callback member 'text'
      ///
      ///     - Inherited signals from Widget
      ///
      /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
      class TGUI_API TextBox : public Widget
      {
      public:
  
          typedef std::shared_ptr<TextBox> Ptr; ///< Shared widget pointer
          typedef std::shared_ptr<const TextBox> ConstPtr; ///< Shared constant widget pointer
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          // Default constructor
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          TextBox();
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Copy constructor
          ///
          /// @param copy  Instance to copy
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          TextBox(const TextBox& copy);
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Overload of assignment operator
          ///
          /// @param right  Instance to assign
          ///
          /// @return Reference to itself
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          TextBox& operator= (const TextBox& right);
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Create the text box
          ///
          /// @param themeFileFilename  Filename of the theme file.
          /// @param section            The section in the theme file to read.
          ///
          /// @throw Exception when the theme file could not be opened.
          /// @throw Exception when the theme file did not contain the requested section with the needed information.
          /// @throw Exception when one of the images, described in the theme file, could not be loaded.
          ///
          /// When an empty string is passed as filename, the built-in white theme will be used.
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          static TextBox::Ptr create(const std::string& themeFileFilename = "", const std::string& section = "TextBox");
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Makes a copy of another text box
          ///
          /// @param textBox  The other text box
          ///
          /// @return The new text box
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          static TextBox::Ptr copy(TextBox::ConstPtr textBox);
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
          ///
          /// @return Reference to the renderer
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          std::shared_ptr<TextBoxRenderer> getRenderer() const
          {
              return std::static_pointer_cast<TextBoxRenderer>(m_renderer);
          }
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Set the position of the widget
          ///
          /// This function completely overwrites the previous position.
          /// See the move function to apply an offset based on the previous position instead.
          /// The default position of a transformable widget is (0, 0).
          ///
          /// @param position  New position
          ///
          /// @see move, getPosition
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          virtual void setPosition(const Layout2d& position) override;
          using Transformable::setPosition;
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Changes the size of the text box.
          ///
          /// This size does not include the borders.
          ///
          /// @param size  The new size of the text box
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          virtual void setSize(const Layout2d& size) override;
          using Transformable::setSize;
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Returns the full size of the text box.
          ///
          /// This is the size including the borders.
          ///
          /// @return Full size of the text box
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          virtual sf::Vector2f getFullSize() const override;
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Changes the font of the text in the widget.
          ///
          /// @param font  The new font.
          ///
          /// When you don't call this function then the font from the parent widget will be used.
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          virtual void setFont(const Font& font) override;
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Changes the text of the text box.
          ///
          /// @param text  New text
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          void setText(const sf::String& text);
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Appends some text to the text that was already in the text box.
          ///
          /// @param text  Text that will be added to the text that is already in the text box
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          void addText(const sf::String& text);
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Returns the text of the text box.
          ///
          /// @return  The text that is currently inside the text box
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          sf::String getText() const
          {
              return m_text;
          }
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Returns the text that you currently have selected.
          ///
          /// @return The selected text of the text box.
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          sf::String getSelectedText() const;
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Changes the character size of the text.
          ///
          /// @param size  The new text size.
          ///              The minimum text size is 8.
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          void setTextSize(unsigned int size);
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Returns the character size of the text.
          ///
          /// @return The current text size.
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          unsigned int getTextSize() const
          {
              return m_textSize;
          }
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Changes the maximum character limit.
          ///
          /// @param maxChars  The new character limit.
          ///                  Set it to 0 to disable the limit.
          ///
          /// This character limit is disabled by default.
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          void setMaximumCharacters(std::size_t maxChars = 0);
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Returns the maximum character limit.
          ///
          /// @return The character limit.
          ///         The function will return 0 when there is no limit.
          ///
          /// There is no character limit by default.
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          std::size_t getMaximumCharacters() const
          {
              return m_maxChars;
          }
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Changes the scrollbar of the text box.
          ///
          /// @param scrollbar The new scrollbar to use in the text box
          ///
          /// Pass a nullptr to remove the scrollbar. Note that when removing the scrollbar while there are too many items
          /// to fit in the text box then the excess items will be removed.
          ///
          /// The scrollbar should have no parent and you should not change it yourself.
          /// The function is meant to be used like this:
          /// @code
          /// textBox->setScrollbar(theme->load("scrollbar"));
          /// @endcode
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          void setScrollbar(Scrollbar::Ptr scrollbar);
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Access the scrollbar of the text box
          ///
          /// @return scrollbar in the text box
          ///
          /// You should not change the scrollbar yourself
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          Scrollbar::Ptr getScrollbar();
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Make the text box read-only or make it writable again
          ///
          /// @param readOnly  Should the text box be read-only?
          ///
          /// When the text box is read-only, you can no longer delete characters and type text.
          /// Selecting text, copying text and even calling the setText function will still work.
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          void setReadOnly(bool readOnly = true);
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Check if the text box read-only or writable
          ///
          /// @return Is the text box read-only?
          ///
          /// When the text box is read-only, you can no longer delete characters and type text.
          /// Selecting text, copying text and even calling the setText function will still work.
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          bool isReadOnly();
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Changes the opacity of the widget.
          ///
          /// @param opacity  The opacity of the widget. 0 means completely transparent, while 1 (default) means fully opaque.
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          virtual void setOpacity(float opacity) override;
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Returns the distance between the position where the widget is drawn and where the widget is placed
          ///
          /// This is basically the width and height of the optional borders drawn around widgets.
          ///
          /// @return Offset of the widget
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          virtual sf::Vector2f getWidgetOffset() const override;
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @internal
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          virtual bool mouseOnWidget(float x, float y) const override;
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @internal
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          virtual void leftMousePressed(float x, float y) override;
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @internal
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          virtual void leftMouseReleased(float x, float y) override;
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @internal
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          virtual void mouseMoved(float x, float y) override;
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @internal
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          virtual void keyPressed(const sf::Event::KeyEvent& event) override;
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @internal
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          virtual void textEntered(sf::Uint32 Key) override;
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @internal
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          virtual void mouseWheelMoved(int delta, int x, int y) override;
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @internal
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          virtual void mouseNoLongerOnWidget() override;
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @internal
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          virtual void mouseNoLongerDown() override;
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @internal
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          virtual void widgetFocused() override;
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @internal
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          virtual void widgetUnfocused() override;
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
      protected:
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          // This function will search after which character the caret should be placed. It will not change the caret position.
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          sf::Vector2<std::size_t> findCaretPosition(sf::Vector2f position);
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          // Converts the two dimensional caret positions into a one dimensional position in the text.
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          std::pair<std::size_t, std::size_t> findTextCaretPosition();
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          // This function is called when you are selecting text.
          // It will find out which part of the text is selected.
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          void selectText(float posX, float posY);
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          // Removes the selected characters. This function is called when pressing backspace, delete or a letter while there were
          // some characters selected.
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          void deleteSelectedCharacters();
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          // Rearrange the text inside the text box (by using word wrap).
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          void rearrangeText(bool keepSelection);
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          // This function will split the text into five pieces so that the text can be easily drawn.
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          void updateSelectionTexts();
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
      protected:
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          // This function is called every frame with the time passed since the last frame.
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          virtual void update(sf::Time elapsedTime) override;
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Reload the widget
          ///
          /// @param primary    Primary parameter for the loader
          /// @param secondary  Secondary parameter for the loader
          /// @param force      Try to only change the looks of the widget and not alter the widget itself when false
          ///
          /// @throw Exception when the connected theme could not create the widget
          ///
          /// When primary is an empty string the built-in white theme will be used.
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          virtual void reload(const std::string& primary = "", const std::string& secondary = "", bool force = false) override;
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          // Makes a copy of the widget
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          virtual Widget::Ptr clone() const override
          {
              return std::make_shared<TextBox>(*this);
          }
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          // Draws the widget on the render target.
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const override;
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
      protected:
  
          sf::String   m_text;
          unsigned int m_textSize = 18;
          unsigned int m_lineHeight = 24;
  
          std::vector<sf::String> m_lines = std::vector<sf::String>{""}; // Did not compile in VS2013 with just braces
  
          // The maximum characters (0 by default, which means no limit)
          std::size_t m_maxChars = 0;
  
          // What is known about the visible lines?
          std::size_t m_topLine = 1;
          std::size_t m_visibleLines = 1;
  
          // Information about the selection
          sf::Vector2<std::size_t> m_selStart;
          sf::Vector2<std::size_t> m_selEnd;
  
          // Information about the caret
          sf::Vector2f m_caretPosition;
          bool m_caretVisible = true;
  
          sf::Text m_textBeforeSelection;
          sf::Text m_textSelection1;
          sf::Text m_textSelection2;
          sf::Text m_textAfterSelection1;
          sf::Text m_textAfterSelection2;
  
          std::vector<sf::FloatRect> m_selectionRects;
  
          // The scrollbar
          Scrollbar::Ptr m_scroll = std::make_shared<Scrollbar>();
  
          // Is there a possibility that the user is going to double click?
          bool m_possibleDoubleClick = false;
  
          bool m_readOnly = false;
  
          friend class TextBoxRenderer;
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
      };
  
  
      /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
      class TGUI_API TextBoxRenderer : public WidgetRenderer, public WidgetBorders, public WidgetPadding
      {
      public:
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Constructor
          ///
          /// @param textBox  The text box that is connected to the renderer
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          TextBoxRenderer(TextBox* textBox) : m_textBox{textBox} {}
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Change a property of the renderer
          ///
          /// @param property  The property that you would like to change
          /// @param value     The new serialized value that you like to assign to the property
          ///
          /// @throw Exception when deserialization fails or when the widget does not have this property.
          /// @throw Exception when loading scrollbar fails with the theme connected to the list box
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          virtual void setProperty(std::string property, const std::string& value) override;
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Change a property of the renderer
          ///
          /// @param property  The property that you would like to change
          /// @param value     The new value that you like to assign to the property.
          ///                  The ObjectConverter is implicitly constructed from the possible value types.
          ///
          /// @throw Exception for unknown properties or when value was of a wrong type.
          /// @throw Exception when loading scrollbar fails with the theme connected to the list box
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          virtual void setProperty(std::string property, ObjectConverter&& value) override;
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Retrieve the value of a certain property
          ///
          /// @param property  The property that you would like to retrieve
          ///
          /// @return The value inside a ObjectConverter object which you can extract with the correct get function or
          ///         an ObjectConverter object with type ObjectConverter::Type::None when the property did not exist.
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          virtual ObjectConverter getProperty(std::string property) const override;
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Get a map with all properties and their values
          ///
          /// @return Property-value pairs of the renderer
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          virtual std::map<std::string, ObjectConverter> getPropertyValuePairs() const override;
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Set the background color that will be used inside the text box.
          ///
          /// @param backgroundColor  The new background color.
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          void setBackgroundColor(const Color& backgroundColor);
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Set the text color that will be used inside the text box.
          ///
          /// @param textColor  The new text color.
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          void setTextColor(const Color& textColor);
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Set the text color of the selected text that will be used inside the text box.
          ///
          /// @param selectedTextColor  The new text color.
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          void setSelectedTextColor(const Color& selectedTextColor);
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Set the background color of the selected text that will be used inside the text box.
          ///
          /// @param selectedTextBackgroundColor  The new background color.
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          void setSelectedTextBackgroundColor(const Color& selectedTextBackgroundColor);
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Set the border color that will be used inside the text box.
          ///
          /// @param borderColor  The color of the borders
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          void setBorderColor(const Color& borderColor);
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Set the color that will be used inside the text box for the blinking caret.
          ///
          /// @param caretColor  The color of the blinking caret
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          void setCaretColor(const Color& caretColor);
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief This will change the width of the blinking caret.
          ///
          /// @param width  New width of the caret
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          void setCaretWidth(float width);
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Changes the background image
          ///
          /// @param texture  New background texture
          ///
          /// When this image is set, the background color property will be ignored.
          /// Pass an empty string to unset the image, in this case the background color property will be used again.
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          void setBackgroundTexture(const Texture& texture);
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Changes the padding of the text box.
          ///
          /// This padding will be scaled together with the background image.
          /// If there is no background image, or when 9-slice scaling is used, the padding will be exactly what you pass here.
          ///
          /// @param padding  The padding width and height
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          virtual void setPadding(const Padding& padding) override;
          using WidgetPadding::setPadding;
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Changes the scrollbar of the text box.
          ///
          /// @param scrollbarThemeFileFilename  Filename of the theme file.
          /// @param section  The section to look for inside the theme file.
          ///
          /// @throw Exception when the theme file could not be opened.
          /// @throw Exception when the theme file did not contain the requested section with the needed information.
          /// @throw Exception when one of the images, described in the theme file, could not be loaded.
          ///
          /// When an empty string is passed as filename, the built-in white theme will be used.
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          void setScrollbar(const std::string& scrollbarThemeFileFilename = "", const std::string& section = "Scrollbar");
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          // Draws the widget on the render target.
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          void draw(sf::RenderTarget& target, sf::RenderStates states) const;
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
      private:
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          // Returns the padding, which is possibly scaled with the background image.
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          Padding getScaledPadding() const;
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          // Makes a copy of the renderer
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          virtual std::shared_ptr<WidgetRenderer> clone(Widget* widget) override;
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
      protected:
  
          TextBox* m_textBox;
  
          float m_caretWidth;
  
          Texture   m_backgroundTexture;
  
          sf::Color m_textColor;
          sf::Color m_selectedTextColor;
          sf::Color m_caretColor;
          sf::Color m_backgroundColor;
          sf::Color m_selectedTextBgrColor;
          sf::Color m_borderColor;
  
          friend class TextBox;
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
      };
  
      /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  }
  
  /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  #endif // TGUI_TEXT_BOX_HPP
  