UI.h

/*
 * Gamedev Framework (gf)
 * Copyright (C) 2016-2019 Julien Bernard
 *
 * 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_UI_H
#define GF_UI_H

#include <cstdint>
#include <memory>

#include "ArrayRef.h"
#include "BufferRef.h"
#include "Drawable.h"
#include "Event.h"
#include "Flags.h"
#include "Font.h"
#include "Path.h"
#include "Portability.h"
#include "StringRef.h"
#include "Types.h"
#include "Vector.h"

namespace gf {
#ifndef DOXYGEN_SHOULD_SKIP_THIS
inline namespace v1 {
#endif

  class Texture;

  enum class UIWindow : uint32_t {
    Border          = 0x0001, 
    Movable         = 0x0002, 
    Scalable        = 0x0004, 
    Closable        = 0x0008, 
    Minimizable     = 0x0010, 
    NoScrollbar     = 0x0020, 
    Title           = 0x0040, 
    ScrollAutoHide  = 0x0080, 
    Background      = 0x0100, 
    ScaleLeft       = 0x0200, 
    NoInput         = 0x0400, 
  };

  using UIWindowFlags = Flags<UIWindow>;

  enum class UICollapse : bool {
    Minimized = false,  
    Maximized = true,   
  };

  enum class UILayout {
    Dynamic = 0,  
    Static  = 1,  
  };

  enum class UITree {
    Node  = 0,  
    Tab   = 1,  
  };

  enum class UIAlignment {
    Left    = 0x10 | 0x01,  
    Center  = 0x10 | 0x02,  
    Right   = 0x10 | 0x04,  
  };

  using UIScroll = Vector2u;

  enum class UIButtonBehavior {
    Default   = 0,  
    Repeater  = 1,  
  };

  enum class UIProgress : bool {
    Fixed = false,      
    Modifyable = true,  
  };

  enum class UISymbol {
    None,           
    X,              
    Underscore,     
    CircleSolid,    
    CircleOutline,  
    RectSolid,      
    RectOutline,    
    TriangleUp,     
    TriangleDown,   
    TriangleLeft,   
    TriangleRight,  
    Plus,           
    Minus,          
  };

  enum class UIEdit : uint32_t {
    Default             = 0x0000,
    ReadOnly            = 0x0001,
    AutoSelect          = 0x0002,
    SigEnter            = 0x0004,
    AllowTab            = 0x0008,
    NoCursor            = 0x0010,
    Selectable          = 0x0020,
    Clipboard           = 0x0040,
    CtrlEnterNewline    = 0x0080,
    NoHorizontalScroll  = 0x0100,
    AlwaysInsertMode    = 0x0200,
    Multiline           = 0x0400,
    GotoEndOnActivate   = 0x0800,
  };

  using UIEditFlags = Flags<UIEdit>;

  struct GF_API UIEditType {
    static const UIEditFlags Simple;
    static const UIEditFlags Field;
    static const UIEditFlags Box;
    static const UIEditFlags Editor;
  };

  enum class UIEditEvent : uint32_t {
    Active      = 0x0001, 
    Inactive    = 0x0002, 
    Activated   = 0x0004, 
    Deactivated = 0x0008, 
    Commited    = 0x0010, 
  };

  using UIEditEventFlags = Flags<UIEditEvent>;

  enum class UIEditFilter {
    Default,
    Ascii,
    Float,
    Decimal,
    Hex,
    Oct,
    Binary,
  };

  struct UIBrowser {
    Path currentPath;   
    Path selectedPath;  
  };

  enum class UIPopup {
    Static  = 0,  
    Dynamic = 1,  
  };

  enum class UIPredefinedStyle {
    Default,  
    White,    
    Red,      
    Blue,     
    Dark,     
  };

  class GF_API UICharBuffer {
  public:
    UICharBuffer(std::size_t capacity);
    ~UICharBuffer();

    UICharBuffer(const UICharBuffer&) = delete;
    UICharBuffer& operator=(const UICharBuffer&) = delete;

    UICharBuffer(UICharBuffer&& other) noexcept;
    UICharBuffer& operator=(UICharBuffer&& other) noexcept;

    std::string asString() const {
      return std::string(m_data, m_length);
    }

    StringRef asStringRef() const {
      return StringRef(m_data, m_length);
    }

    void clear();
    void append(const UICharBuffer& other);
    void append(const std::string& other);

  private:
    friend class UI;

    char *m_data;
    std::size_t m_length;
    std::size_t m_capacity;
  };

  class GF_API UI : public Drawable {
  public:
    static constexpr unsigned DefaultCharacterSize = 13;

    UI(Font& font, unsigned characterSize = DefaultCharacterSize);

    ~UI();

    UI(const UI&) = delete;

    UI& operator=(const UI&) = delete;

    UI(UI&& other) noexcept;

    UI& operator=(UI&& other) noexcept;

    void processEvent(const Event& event);

    void setCharacterSize(unsigned characterSize);

    bool begin(const std::string& title, const RectF& bounds, UIWindowFlags flags = None);

    void end();

    RectF windowGetBounds();

    void layoutRowDynamic(float height, int cols);

    void layoutRowStatic(float height, int itemWidth, int cols);

    void layoutRowBegin(UILayout format, float height, int cols);

    void layoutRowPush(float width);

    void layoutRowEnd();

    void layoutRow(UILayout format, float height, ArrayRef<float> ratio);

    void separator(float height);

    bool groupBegin(const std::string& title, UIWindowFlags flags = None);

    void groupEnd();

    bool groupScrolledBegin(UIScroll& scroll, const std::string& title, UIWindowFlags flags = None);

    void groupScrolledEnd();

    bool treePush(UITree type, const std::string& title, UICollapse& state);

    void treePop();

    void label(StringRef title, UIAlignment align = UIAlignment::Left);

    void labelColored(const Color4f& color, StringRef title, UIAlignment align = UIAlignment::Left);

    void labelWrap(StringRef title);

    void labelWrapColored(const Color4f& color, StringRef title);

    void image(const Texture& texture, const RectF& textureRect);

    void buttonSetBehavior(UIButtonBehavior behavior);

    bool buttonPushBehavior(UIButtonBehavior behavior);

    bool buttonPopBehavior();

    bool buttonLabel(StringRef title);

    bool buttonColor(const Color4f& color);

    bool buttonSymbol(UISymbol symbol);

    bool buttonSymbolLabel(UISymbol symbol, StringRef title, UIAlignment align = UIAlignment::Left);

    bool checkbox(StringRef title, bool& active);

    bool checkboxFlags(StringRef title, unsigned& flags, unsigned value);

    bool option(StringRef title, bool active);

    bool radio(StringRef title, bool& active);

    bool selectableLabel(StringRef title, UIAlignment align, bool& value);

    bool sliderFloat(float min, float& val, float max, float step);

    bool sliderInt(int min, int& val, int max, int step);

    bool progress(std::size_t& current, std::size_t max, UIProgress modifyable = UIProgress::Modifyable);

    bool colorPicker(Color4f& color);

    void propertyInt(const std::string& name, int min, int& val, int max, int step, float incPerPixel);

    void propertyFloat(const std::string& name, float min, float& val, float max, float step, float incPerPixel);

    void propertyDouble(const std::string& name, double min, double& val, double max, double step, float incPerPixel);

    UIEditEventFlags edit(UIEditFlags flags, UICharBuffer& buffer, UIEditFilter filter = UIEditFilter::Default);

    bool fileSelector(UIBrowser& browser, const std::string& title, const RectF& bounds);

    bool popupBegin(UIPopup type, const std::string& title, UIWindowFlags flags, const RectF& bounds);

    void popupClose();

    void popupEnd();

    void combobox(const std::vector<std::string>& items, int& selected, int itemHeight, Vector2f size);

    void comboboxSeparator(const std::string& itemsSeparatedBySeparator, char separator, int& selected, int itemHeight, Vector2f size);

    bool comboBeginLabel(StringRef selected, Vector2f size);

    bool comboBeginColor(const Color4f& color, Vector2f size);

    bool comboBeginSymbol(UISymbol symbol, Vector2f size);

    bool comboBeginSymbolLabel(UISymbol symbol, StringRef selected, Vector2f size);

    bool comboItemLabel(StringRef title, UIAlignment align = UIAlignment::Left);

    bool comboItemSymbolLabel(UISymbol symbol, StringRef title, UIAlignment align = UIAlignment::Left);

    void comboClose();

    void comboEnd();

    bool contextualBegin(UIWindowFlags flags, Vector2f size, const RectF& triggerBounds);

    bool contextualItemLabel(StringRef title, UIAlignment align = UIAlignment::Left);

    bool contextualItemSymbolLabel(UISymbol symbol, StringRef title, UIAlignment align = UIAlignment::Left);

    void contextualClose();

    void contextualEnd();

    void tooltip(const std::string& text);

    bool tooltipBegin(float width);

    void tooltipEnd();

    void menubarBegin();

    void menubarEnd();

    bool menuBeginLabel(StringRef title, UIAlignment align, Vector2f size);

    bool menuBeginSymbol(const std::string& id, UISymbol symbol, Vector2f size);

    bool menuBeginSymbolLabel(UISymbol symbol, StringRef title, UIAlignment align, Vector2f size);

    bool menuItemLabel(StringRef title, UIAlignment align = UIAlignment::Left);

    bool menuItemSymbolLabel(UISymbol symbol, StringRef title, UIAlignment align = UIAlignment::Left);

    void menuClose();

    void menuEnd();

    RectF getWidgetBounds();

    bool isWidgetHovered();

    RectF getWindowBounds();

    bool isWindowHovered();

    void spacing(int cols);

    void setPredefinedStyle(UIPredefinedStyle style);

    virtual void draw(RenderTarget &target, const RenderStates& states) override;

  private:
    enum class State {
      Start,
      Input,
      Setup,
      Draw,
    };

    void setState(State state);

  private:
    struct UIImpl;

    std::unique_ptr<UIImpl> m_impl;
  };


#ifndef DOXYGEN_SHOULD_SKIP_THIS
}
#endif

#ifndef DOXYGEN_SHOULD_SKIP_THIS
template<>
struct EnableBitmaskOperators<UIWindow> {
  static constexpr bool value = true;
};

template<>
struct EnableBitmaskOperators<UIEdit> {
  static constexpr bool value = true;
};

template<>
struct EnableBitmaskOperators<UIEditEvent> {
  static constexpr bool value = true;
};
#endif

}

#endif // GF_UI_H