Widgets.h

/*
 * Gamedev Framework (gf)
 * Copyright (C) 2016-2022 Julien Bernard
 * Copyright (C) 2018 Lilian Franchi
 *
 * 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 GF_WIDGETS_H
#define GF_WIDGETS_H
 
#include "BasicSprite.h"
#include "BasicText.h"
#include "GraphicsApi.h"
#include "Shapes.h"
#include "Vector.h"
#include "VertexArray.h"
#include "Widget.h"
 
namespace gf {
#ifndef DOXYGEN_SHOULD_SKIP_THIS
inline namespace v1 {
#endif
 
  struct RenderStates;
  class RenderTarget;
 
  class GF_GRAPHICS_API TextWidget : public Widget {
  public:
    TextWidget(std::string text, Font& font, unsigned characterSize = 30);
 
    void draw(RenderTarget &target, const RenderStates& states) override;
 
    bool contains(Vector2f coords) override;
 
    void setString(std::string string);
 
    const std::string& getString() const;
 
    void setAlignment(Alignment align);
 
    Alignment getAlignment() const;
 
    void setParagraphWidth(float paragraphWidth);
 
    float getParagraphWidth() const;
 
    void setLineSpacing(float spacingFactor);
 
    float getLineSpacing() const;
 
    void setLetterSpacing(float spacingFactor);
 
    float getLetterSpacing() const;
 
    void setCharacterSize(unsigned characterSize);
 
    unsigned getCharacterSize() const;
 
    void setTextOutlineThickness(float thickness);
 
    void setDisabledTextColor(const Color4f &color);
 
    void setDisabledTextOutlineColor(const Color4f &color);
 
    void setDefaultTextColor(const Color4f &color);
 
    void setDefaultTextOutlineColor(const Color4f &color);
 
    void setSelectedTextColor(const Color4f &color);
 
    void setSelectedTextOutlineColor(const Color4f &color);
 
 
    RectF getLocalBounds() const {
      return m_basic.getLocalBounds();
    }
 
    void setAnchor(Anchor anchor);
 
  protected:
    void updateCurrentStateColors();
    void updateColors(Color4f textColor, Color4f outlineColor);
    void updateGeometry();
 
    void onStateChanged() override;
 
    BasicText& getText() {
      return m_basic;
    }
 
  private:
    BasicText m_basic;
    VertexArray m_vertices;
    VertexArray m_outlineVertices;
 
    Color4f m_disabledTextColor;
    Color4f m_disabledTextOutlineColor;
 
    Color4f m_defaultTextColor;
    Color4f m_defaultTextOutlineColor;
 
    Color4f m_selectedTextColor;
    Color4f m_selectedTextOutlineColor;
  };
 
  class GF_GRAPHICS_API TextButtonWidget : public TextWidget {
  public:
    TextButtonWidget(std::string text, Font& font, unsigned characterSize = 30);
 
    void draw(RenderTarget &target, const RenderStates& states) override;
 
    bool contains(Vector2f coords) override;
 
    void setBackgroundOutlineThickness(float thickness);
 
    void setDisabledBackgroundColor(const Color4f &color);
 
    void setDisabledBackgroundOutlineColor(const Color4f &color);
 
    void setDefaultBackgroundColor(const Color4f &color);
 
    void setDefaultBackgroundOutlineColor(const Color4f &color);
 
    void setSelectedBackgroundColor(const Color4f &color);
 
    void setSelectedBackgroundOutlineColor(const Color4f &color);
 
    void setRadius(float radius) {
      m_radius = radius;
      updateGeometry();
    }
 
    void setPadding(float padding) {
      m_padding = padding;
      updateGeometry();
    }
 
  protected:
    void updateGeometry();
 
    void onStateChanged() override;
 
  private:
    gf::RoundedRectangleShape m_rect;
 
    float m_backgroundOutlineThickness;
 
    Color4f m_disabledBackgroundColor;
    Color4f m_disabledBackgroundOutlineColor;
 
    Color4f m_defaultBackgroundColor;
    Color4f m_defaultBackgroundOutlineColor;
 
    Color4f m_selectedBackgroundColor;
    Color4f m_selectedBackgroundOutlineColor;
 
    float m_radius;
    float m_padding;
  };
 
  class GF_GRAPHICS_API SpriteWidget : public Widget {
  public:
    SpriteWidget() = default;
 
    SpriteWidget(const Texture& texture, const RectF& defaultRect, const RectF& selectedRect, const RectF& disabledRect);
 
    SpriteWidget(const Texture& defaultTexture, const Texture& selectedTexture, const Texture& disabledTexture);
 
    void draw(RenderTarget &target, const RenderStates& states) override;
 
    bool contains(Vector2f coords) override;
 
    void setDisabledSprite(const Texture& texture, const RectF& textureRect);
 
    void unsetDisabledSprite();
 
    void setDefaultSprite(const Texture& texture, const RectF& textureRect);
 
    void unsetDefaultSprite();
 
    void setSelectedSprite(const Texture& texture, const RectF& textureRect);
 
    void unsetSelectedSprite();
 
    RectF getLocalBounds() const {
      return getSprite().getLocalBounds();
    }
 
    void setAnchor(Anchor anchor);
 
  private:
    void updateGeometry();
 
    void onStateChanged() override;
 
  private:
    BasicSprite& getSprite();
    const BasicSprite& getSprite() const;
 
  private:
    BasicSprite m_disabledSprite;
    BasicSprite m_defaultSprite;
    BasicSprite m_selectedSprite;
    Vertex m_vertices[4];
  };
 
  class GF_GRAPHICS_API ChoiceSpriteWidget : public Widget {
  public:
    ChoiceSpriteWidget(const Texture& texture, const RectF& emptyRect, const RectF& chosenRect);
 
    ChoiceSpriteWidget(const Texture& emptyTexture, const Texture& chosenTexture);
 
    void draw(RenderTarget &target, const RenderStates& states) override;
 
    bool contains(Vector2f coords) override;
 
    void setChosen(bool chosen = true);
 
    bool isChosen() const noexcept {
      return m_isChosen;
    }
 
    void setEmptySprite(const Texture& texture, const RectF& textureRect);
 
    void setChosenSprite(const Texture& texture, const RectF& textureRect);
 
  protected:
    void triggered() override;
 
  private:
    void updateGeometry();
 
  private:
    BasicSprite& getSprite();
    const BasicSprite& getSprite() const;
 
  private:
    BasicSprite m_empty;
    BasicSprite m_chosen;
    bool m_isChosen;
    Vertex m_vertices[4];
  };
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
}
#endif
}
 
#endif // GF_WIDGETS_H