layouter.h

Go to the documentation of this file.

/*
 * STLL Simple Text Layouting Library
 *
 * STLL is the legal property of its developers, whose
 * names are listed in the COPYRIGHT file, which is included
 * within the source distribution.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License
 * as published by the Free Software Foundation; either version 2.1
 * of the License, or (at your option) any later version.

 * This program 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 this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
#ifndef STLL_LAYOUTER_H
#define STLL_LAYOUTER_H

#include "layouterFont.h"

#include "color.h"

#include <boost/icl/split_interval_map.hpp>
#include <boost/icl/closed_interval.hpp>

#include <string>
#include <vector>
#include <memory>

#include <stdint.h>

namespace STLL {

class CommandData_c
{
public:
  enum
  {
    CMD_GLYPH,  
    CMD_RECT,   
    CMD_IMAGE   
  } command;    

  int32_t x;  
  int32_t y;  

  glyphIndex_t glyphIndex;

  std::shared_ptr<FontFace_c> font;

  uint32_t w;  
  uint32_t h;  

  Color_c c;

  uint16_t blurr;

  std::string imageURL; 

  CommandData_c(std::shared_ptr<FontFace_c> f, glyphIndex_t i, int32_t x_, int32_t y_, Color_c c_, uint16_t rad) :
  command(CMD_GLYPH), x(x_), y(y_), glyphIndex(i), font(f), w(0), h(0), c(c_), blurr(rad) {}

  CommandData_c(const std::string & i, int32_t x_, int32_t y_, uint32_t w_, uint32_t h_) :
  command(CMD_IMAGE), x(x_), y(y_), glyphIndex(0), w(w_), h(h_), blurr(0), imageURL(i) {}

  CommandData_c(int32_t x_, int32_t y_, uint32_t w_, uint32_t h_, Color_c c_, uint16_t rad) :
  command(CMD_RECT), x(x_), y(y_), glyphIndex(0), w(w_), h(h_), c(c_), blurr(rad) {}
};

class TextLayout_c
{
  private:
    // position where you can add additional text after this ...
    uint32_t height;
    // left and right edge
    int32_t left, right;
    // vertical position of the very first baseline in this layout
    int32_t firstBaseline;
    // the drawing commands that make up this layout
    std::vector<CommandData_c> data;

  public:

    const std::vector<CommandData_c> getData(void) const { return data; }

    class Rectangle_c
    {
      public:
        int x, y, w, h;
    };

    class LinkInformation_c
    {
      public:
        std::string url;
        std::vector<Rectangle_c> areas;
    };

    std::vector<LinkInformation_c> links;

    template <class... Args>
    void addCommand(Args&&... args)
    {
      data.emplace_back(std::forward<Args>(args)...);
    }

    void addCommand(const CommandData_c & c)
    {
      data.push_back(c);
    }

    template <class... Args>
    void addCommandStart(Args&&... args)
    {
      data.emplace(data.begin(), std::forward<Args>(args)...);
    }

    void addCommandStart(const CommandData_c & d)
    {
      data.insert(data.begin(), d);
    }

    void append(const TextLayout_c & l, int dx = 0, int dy = 0);

    void operator=(TextLayout_c && l)
    {
      data.swap(l.data);
      height = l.height;
      left = l.left;
      right = l.right;
      firstBaseline = l.firstBaseline;
      swap(links, l.links);
    }

    void operator=(const TextLayout_c & l)
    {
      data = l.data;
      height = l.height;
      left = l.left;
      right = l.right;
      firstBaseline = l.firstBaseline;
      links = l.links;
    }

    ~TextLayout_c(void) { }

    TextLayout_c(void);

    TextLayout_c(const TextLayout_c & src);

    TextLayout_c(TextLayout_c && src);

    void shift(int32_t dx, int32_t dy);

    uint32_t getHeight(void) const { return height; }

    void setHeight(uint32_t h) { height = h; }

    int32_t getLeft(void) const { return left; }

    void setLeft(int32_t l) { left = l; }

    int32_t getRight(void) const { return right; }

    void setRight(int32_t r) { right = r; }

    void setFirstBaseline(int32_t r) { firstBaseline = r; }

    int32_t getFirstBaseline(void) const { return firstBaseline; }
};

class CodepointAttributes_c
{
  public:

  Color_c c;

  Font_c font;

  std::string lang;

  static const uint8_t FL_UNDERLINE = 1;

  uint8_t flags;

  class Shadow_c
  {
    public:

      Color_c c;

      int8_t dx;

      int8_t dy;

      int16_t blurr;

      bool operator==(const struct Shadow_c & rhs) const
      {
        return c == rhs.c && dx == rhs.dx && dy == rhs.dy && blurr == rhs.blurr;
      }
  };

  std::vector<Shadow_c> shadows;

  std::shared_ptr<TextLayout_c> inlay;

  int32_t baseline_shift;

  size_t link;

  CodepointAttributes_c(void) : lang(""), flags(0), inlay(0), baseline_shift(0), link(0) { }

  bool operator==(const CodepointAttributes_c & rhs) const
  {
    return c == rhs.c && font == rhs.font && lang == rhs.lang
      && flags == rhs.flags && shadows.size() && rhs.shadows.size()
      && std::equal(shadows.begin(), shadows.end(), rhs.shadows.begin())
      && inlay == rhs.inlay && baseline_shift == rhs.baseline_shift
      && link == rhs.link;
  }

  CodepointAttributes_c operator += (const CodepointAttributes_c & rhs)
  {
    // when someone tries to overwrite the attributes, we take over the new ones
    c = rhs.c;
    font = rhs.font;
    lang = rhs.lang;
    flags = rhs.flags;
    shadows = rhs.shadows;
    inlay = rhs.inlay;
    baseline_shift = rhs.baseline_shift;
    link = rhs.link;

    return *this;
  }
};


class AttributeIndex_c
{
  private:
    boost::icl::interval_map<size_t, CodepointAttributes_c> attr;

  public:
    AttributeIndex_c(void) { }

    AttributeIndex_c(const CodepointAttributes_c & a)
    {
      attr += std::make_pair(boost::icl::interval<size_t>::closed(0, SIZE_MAX), a);
    }

    void set(size_t i, CodepointAttributes_c a)
    {
      attr += std::make_pair(boost::icl::interval<size_t>::closed(i, i), a);
    }

    void set(size_t start, size_t end, CodepointAttributes_c a)
    {
      attr += std::make_pair(boost::icl::interval<size_t>::closed(start, end), a);
    }

    const CodepointAttributes_c & get(size_t i) const
    {
      return attr.find(i)->second;
    }

    bool hasAttribute(size_t i) const
    {
      return attr.find(i) != attr.end();
    }
};

class Shape_c
{
  public:
    virtual int32_t getLeft(int32_t top, int32_t bottom) const = 0;

    virtual int32_t getRight(int32_t top, int32_t bottom) const = 0;

    virtual int32_t getLeft2(int32_t top, int32_t bottom) const = 0;

    virtual int32_t getRight2(int32_t top, int32_t bottom) const = 0;
};

class RectangleShape_c : public Shape_c
{
  private:
    int32_t w;

  public:
    RectangleShape_c(int32_t width) : w(width) { }

    virtual int32_t getLeft(int32_t /*top*/, int32_t /*bottom*/) const { return 0; }
    virtual int32_t getLeft2(int32_t /*top*/, int32_t /*bottom*/) const { return 0; }
    virtual int32_t getRight(int32_t /*top*/, int32_t /*bottom*/) const { return w; }
    virtual int32_t getRight2(int32_t /*top*/, int32_t /*bottom*/) const { return w; }
};

class LayoutProperties_c
{
  public:

    enum {
      ALG_LEFT,          
      ALG_RIGHT,         
      ALG_CENTER,        
      ALG_JUSTIFY_LEFT,  
      ALG_JUSTIFY_RIGHT  
    } align = ALG_LEFT;  

    int32_t indent = 0;  

    bool ltr = true;     

    Font_c underlineFont;

    std::vector<std::string> links;

    bool optimizeLinebreaks = true;

    bool hyphenate = true;
};


TextLayout_c layoutParagraph(const std::u32string & txt32, const AttributeIndex_c & attr,
                             const Shape_c & shape, const LayoutProperties_c & prop, int32_t ystart = 0);

}

#endif