Widgets.h

/*
 * Gamedev Framework (gf)
 * Copyright (C) 2016-2019 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 "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_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_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_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_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