text: /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  //
  // TGUI - Texus' Graphical User Interface
  // Copyright (C) 2012-2020 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_COLOR_PICKER_HPP
  #define TGUI_COLOR_PICKER_HPP
  
  
  #include <TGUI/Widgets/ChildWindow.hpp>
  #include <TGUI/Widgets/Slider.hpp>
  #include <TGUI/Widgets/Canvas.hpp>
  #include <TGUI/Widgets/Panel.hpp>
  #include <TGUI/Renderers/ColorPickerRenderer.hpp>
  
  
  /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  
  
  namespace tgui
  {
      /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
      /// @brief Color picker widget
      /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
      class TGUI_API ColorPicker : public ChildWindow
      {
      public:
  
          typedef std::shared_ptr<ColorPicker> Ptr; ///< Shared widget pointer
          typedef std::shared_ptr<const ColorPicker> ConstPtr; ///< Shared constant widget pointer
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          // Default constructor
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          ColorPicker();
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Creates a new color picker widget
          ///
          /// @param title   Title to display in the title bar of the color picker
          /// @param color   Default color to display
          ///
          /// @return The new color picker
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          static ColorPicker::Ptr create(sf::String title = "", Color color = Color::Black);
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Copy constructor
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          ColorPicker(const ColorPicker &copy);
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Move constructor
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          ColorPicker(ColorPicker &&copy);
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Overload of copy assignment operator
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          ColorPicker &operator=(const ColorPicker &right);
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Overload of move assignment operator
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          ColorPicker &operator=(ColorPicker &&right);
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Makes a copy of another color picker
          ///
          /// @param messageBox  The other color picker
          ///
          /// @return The new color picker
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          static ColorPicker::Ptr copy(ColorPicker::ConstPtr colorPicker);
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
          /// @return Temporary pointer to the renderer that may be shared with other widgets using the same renderer
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          ColorPickerRenderer *getSharedRenderer();
  
          const ColorPickerRenderer *getSharedRenderer() const;
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Returns the renderer, which gives access to functions that determine how the widget is displayed
          /// @return Temporary pointer to the renderer
          /// @warning After calling this function, the widget has its own copy of the renderer and it will no longer be shared.
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          ColorPickerRenderer *getRenderer();
  
          const ColorPickerRenderer *getRenderer() const;
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Changes the color of Color Picker
          ///
          /// @param color    The color picked by Color Picker
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          void setColor(const Color &color);
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Returns the picked color
          ///
          /// @return Color that is picked inside Color Picker
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          Color getColor() const;
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @internal
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          void leftMousePressed(Vector2f pos) override;
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @internal
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          void leftMouseButtonNoLongerDown() override;
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @internal
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          void mouseMoved(Vector2f pos) override;
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
      protected:
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          // Makes sure all widgets lie within the window and places them on the correct position.
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          void rearrange();
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Retrieves a signal based on its name
          ///
          /// @param signalName  Name of the signal
          ///
          /// @return Signal that corresponds to the name
          ///
          /// @throw Exception when the name does not match any signal
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          Signal &getSignal(std::string signalName) override;
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Function called when one of the properties of the renderer is changed
          ///
          /// @param property  Lowercase name of the property that was changed
          ///
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          void rendererChanged(const std::string &property) override;
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Saves the widget as a tree node in order to save it to a file
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          std::unique_ptr<DataIO::Node> save(SavingRenderersMap &renderers) const override;
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          /// @brief Loads the widget from a tree of nodes
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          void load(const std::unique_ptr<DataIO::Node> &node, const LoadingRenderersMap &renderers) override;
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          // Makes a copy of the widget
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          Widget::Ptr clone() const override
          {
              return std::make_shared<ColorPicker>(*this);
          }
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
      private:
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          // Figure and connect signals of widgets
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          void identifyButtonsAndConnect();
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
      public:
  
          SignalColor onColorChange = {"ColorChanged"}; ///< Color was changed
          SignalColor onOkPressed = {"OkPressed"}; ///< Ok was pressed
  
  
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
      protected:
          std::shared_ptr<sf::Shader> m_HSV;
  
          Canvas::Ptr m_canvas = Canvas::create({200, 200});
  
          Slider::Ptr m_red = Slider::create(0, 255);
          Slider::Ptr m_green = Slider::create(0, 255);
          Slider::Ptr m_blue = Slider::create(0, 255);
          Slider::Ptr m_alpha = Slider::create(0, 255);
  
          Slider::Ptr m_value = Slider::create(0, 100);
  
          Panel::Ptr m_last = Panel::create({60, 30});
          Panel::Ptr m_current = Panel::create({60, 30});
  
          bool m_colorRead = false;
      };
  
      /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  }
  
  /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  #endif //TGUI_COLOR_PICKER_HPP
  