gfx_layout.h

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef GFX_LAYOUT_H
#define GFX_LAYOUT_H
 
#include "fontcache.h"
#include "gfx_func.h"
#include "core/math_func.hpp"
 
#include <stack>
#include <string_view>
 
struct FontState {
  FontSize fontsize;       
  TextColour cur_colour;   
 
  std::stack<TextColour, std::vector<TextColour>> colour_stack; 
 
  FontState() : fontsize(FS_END), cur_colour(TC_INVALID) {}
  FontState(TextColour colour, FontSize fontsize) : fontsize(fontsize), cur_colour(colour) {}
 
  inline void SetColour(TextColour c)
  {
    assert(((c & TC_COLOUR_MASK) >= TC_BLUE && (c & TC_COLOUR_MASK) <= TC_BLACK) || (c & TC_COLOUR_MASK) == TC_INVALID);
    assert((c & (TC_COLOUR_MASK | TC_FLAGS_MASK)) == c);
    if ((this->cur_colour & TC_FORCED) == 0) this->cur_colour = c;
  }
 
  inline void PopColour()
  {
    if (colour_stack.empty()) return;
    SetColour(colour_stack.top());
    colour_stack.pop();
  }
 
  inline void PushColour()
  {
    colour_stack.push(this->cur_colour);
  }
 
  inline void SetFontSize(FontSize f)
  {
    this->fontsize = f;
  }
};
 
class Font {
public:
  FontCache *fc;     
  TextColour colour; 
 
  Font(FontSize size, TextColour colour);
};
 
using FontMap = std::vector<std::pair<int, Font *>>;
 
class ParagraphLayouter {
public:
  virtual ~ParagraphLayouter() = default;
 
  class Position {
  public:
    int16_t left; 
    int16_t right; 
    int16_t top; 
 
    constexpr inline Position(int16_t left, int16_t right, int16_t top) : left(left), right(right), top(top) { }
 
    constexpr inline Position(const Point &pt) : left(pt.x), right(pt.x), top(pt.y) { }
  };
 
  class VisualRun {
  public:
    virtual ~VisualRun() = default;
    virtual const Font *GetFont() const = 0;
    virtual int GetGlyphCount() const = 0;
    virtual std::span<const GlyphID> GetGlyphs() const = 0;
    virtual std::span<const Position> GetPositions() const = 0;
    virtual int GetLeading() const = 0;
    virtual std::span<const int> GetGlyphToCharMap() const = 0;
  };
 
  class Line {
  public:
    virtual ~Line() = default;
    virtual int GetLeading() const = 0;
    virtual int GetWidth() const = 0;
    virtual int CountRuns() const = 0;
    virtual const VisualRun &GetVisualRun(int run) const = 0;
    virtual int GetInternalCharLength(char32_t c) const = 0;
  };
 
  virtual void Reflow() = 0;
  virtual std::unique_ptr<const Line> NextLine(int max_width) = 0;
};
 
class Layouter : public std::vector<std::unique_ptr<const ParagraphLayouter::Line>> {
  std::string_view string; 
 
  struct LineCacheKey {
    FontState state_before;  
    std::string str;         
  };
 
  struct LineCacheQuery {
    const FontState &state_before; 
    std::string_view str;    
  };
 
  struct LineCacheCompare {
    using is_transparent = void; 
 
    template<typename Key1, typename Key2>
    bool operator()(const Key1 &lhs, const Key2 &rhs) const
    {
      if (lhs.state_before.fontsize != rhs.state_before.fontsize) return lhs.state_before.fontsize < rhs.state_before.fontsize;
      if (lhs.state_before.cur_colour != rhs.state_before.cur_colour) return lhs.state_before.cur_colour < rhs.state_before.cur_colour;
      if (lhs.state_before.colour_stack != rhs.state_before.colour_stack) return lhs.state_before.colour_stack < rhs.state_before.colour_stack;
      return lhs.str < rhs.str;
    }
  };
public:
  struct LineCacheItem {
    /* Stuff that cannot be freed until the ParagraphLayout is freed */
    void *buffer;              
    FontMap runs;              
 
    FontState state_after;     
    std::unique_ptr<ParagraphLayouter> layout = nullptr; 
 
    LineCacheItem() : buffer(nullptr) {}
    ~LineCacheItem() { free(buffer); }
  };
private:
  typedef std::map<LineCacheKey, LineCacheItem, LineCacheCompare> LineCache;
  static LineCache *linecache;
 
  static LineCacheItem &GetCachedParagraphLayout(std::string_view str, const FontState &state);
 
  using FontColourMap = std::map<TextColour, std::unique_ptr<Font>>;
  static FontColourMap fonts[FS_END];
public:
  static Font *GetFont(FontSize size, TextColour colour);
 
  Layouter(std::string_view str, int maxw = INT32_MAX, FontSize fontsize = FS_NORMAL);
  Dimension GetBounds();
  ParagraphLayouter::Position GetCharPosition(std::string_view::const_iterator ch) const;
  ptrdiff_t GetCharAtPosition(int x, size_t line_index) const;
 
  static void Initialize();
  static void ResetFontCache(FontSize size);
  static void ResetLineCache();
  static void ReduceLineCache();
};
 
ParagraphLayouter::Position GetCharPosInString(std::string_view str, const char *ch, FontSize start_fontsize = FS_NORMAL);
ptrdiff_t GetCharAtPosition(std::string_view str, int x, FontSize start_fontsize = FS_NORMAL);
 
#endif /* GFX_LAYOUT_H */