/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/*

 * This file is part of the libmspub project.

 *

 * This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/.

 */

#include "MSPUBCollector.h"

#include <algorithm>

#include <functional>

#include <math.h>

#include <memory>

#include <boost/multi_array.hpp>

#include <unicode/ucsdet.h>

#include <unicode/uloc.h>

#include "Arrow.h"

#include "Coordinate.h"

#include "Dash.h"

#include "Fill.h"

#include "Line.h"

#include "Margins.h"

#include "MSPUBConstants.h"

#include "MSPUBTypes.h"

#include "PolygonUtils.h"

#include "Shadow.h"

#include "ShapeGroupElement.h"

#include "TableInfo.h"

#include "VectorTransformation2D.h"

#include "libmspub_utils.h"

namespace libmspub

{

using namespace std::placeholders;

namespace

{

static void separateTabsAndInsertText(librevenge::RVNGDrawingInterface *iface, const librevenge::RVNGString &text)

{

  if (!iface || text.empty())

    return;

  librevenge::RVNGString tmpText;

  librevenge::RVNGString::Iter i(text);

  for (i.rewind(); i.next();)

  {

    if (*(i()) == '\t')

    {

      if (!tmpText.empty())

      {

        if (iface)

          iface->insertText(tmpText);

        tmpText.clear();

      }

      if (iface)

        iface->insertTab();

    }

    else if (*(i()) == '\n')

    {

      if (!tmpText.empty())

      {

        if (iface)

          iface->insertText(tmpText);

        tmpText.clear();

      }

      if (iface)

        iface->insertLineBreak();

    }

    else

    {

      tmpText.append(i());

    }

  }

  if (iface && !tmpText.empty())

    iface->insertText(tmpText);

}

static void separateSpacesAndInsertText(librevenge::RVNGDrawingInterface *iface, const librevenge::RVNGString &text)

{

  if (!iface)

    return;

  if (text.empty())

  {

    iface->insertText(text);

    return;

  }

  librevenge::RVNGString tmpText;

  int numConsecutiveSpaces = 0;

  librevenge::RVNGString::Iter i(text);

  for (i.rewind(); i.next();)

  {

    if (*(i()) == ' ')

      numConsecutiveSpaces++;

    else

      numConsecutiveSpaces = 0;

    if (numConsecutiveSpaces > 1)

    {

      if (!tmpText.empty())

      {

        separateTabsAndInsertText(iface, tmpText);

        tmpText.clear();

      }

      if (iface)

        iface->insertSpace();

    }

    else

    {

      tmpText.append(i());

    }

  }

  separateTabsAndInsertText(iface, tmpText);

}

struct TableLayoutCell

{

  TableLayoutCell()

    : m_cell(0)

    , m_rowSpan(0)

    , m_colSpan(0)

  {

  }

  unsigned m_cell;

  unsigned m_rowSpan;

  unsigned m_colSpan;

};

bool isCovered(const TableLayoutCell &cell)

{

  assert((cell.m_rowSpan == 0) == (cell.m_colSpan == 0));

  return (cell.m_rowSpan == 0) && (cell.m_colSpan == 0);

}

typedef boost::multi_array<TableLayoutCell, 2> TableLayout;

void createTableLayout(const std::vector<CellInfo> &cells, TableLayout &tableLayout)

{

  for (auto it = cells.begin(); it != cells.end(); ++it)

  {

    if ((it->m_endRow >= tableLayout.shape()[0]) || (it->m_endColumn >= tableLayout.shape()[1]))

    {

      MSPUB_DEBUG_MSG((

                        "cell %u (rows %u to %u, columns %u to %u) overflows the table, ignoring\n",

                        unsigned(int(it - cells.begin())),

                        it->m_startRow, it->m_endRow,

                        it->m_startColumn, it->m_endColumn

                      ));

      continue;

    }

    if (it->m_startRow > it->m_endRow)

    {

      MSPUB_DEBUG_MSG((

                        "cell %u (rows %u to %u) has got negative row span, ignoring\n",

                        unsigned(int(it - cells.begin())),

                        it->m_startRow, it->m_endRow

                      ));

      continue;

    }

    if (it->m_startColumn > it->m_endColumn)

    {

      MSPUB_DEBUG_MSG((

                        "cell %u (columns %u to %u) has got negative column span, ignoring\n",

                        unsigned(int(it - cells.begin())),

                        it->m_startColumn, it->m_endColumn

                      ));

      continue;

    }

    const unsigned rowSpan = it->m_endRow - it->m_startRow + 1;

    const unsigned colSpan = it->m_endColumn - it->m_startColumn + 1;

    if ((rowSpan == 0) != (colSpan == 0))

    {

      MSPUB_DEBUG_MSG((

                        "cell %u (rows %u to %u, columns %u to %u) has got 0 span in one dimension, ignoring\n",

                        unsigned(int(it - cells.begin())),

                        it->m_startRow, it->m_endRow,

                        it->m_startColumn, it->m_endColumn

                      ));

      continue;

    }

    TableLayoutCell &layoutCell = tableLayout[it->m_startRow][it->m_startColumn];

    layoutCell.m_cell = unsigned(int(it - cells.begin()));

    layoutCell.m_rowSpan = rowSpan;

    layoutCell.m_colSpan = colSpan;

  }

}

typedef std::vector<std::pair<unsigned, unsigned> > ParagraphToCellMap_t;

typedef std::vector<librevenge::RVNGString> SpanTexts_t;

typedef std::vector<SpanTexts_t> ParagraphTexts_t;

void mapTableTextToCells(

  const std::vector<TextParagraph> &text,

  const std::vector<unsigned> &tableCellTextEnds,

  const char *const encoding,

  ParagraphToCellMap_t &paraToCellMap,

  ParagraphTexts_t &paraTexts

)

{

  assert(paraToCellMap.empty());

  assert(paraTexts.empty());

  paraToCellMap.reserve(tableCellTextEnds.size());

  paraTexts.reserve(tableCellTextEnds.size());

  unsigned firstPara = 0;

  unsigned offset = 1;

  for (unsigned para = 0; para != text.size() && paraToCellMap.size() < tableCellTextEnds.size(); ++para)

  {

    paraTexts.push_back(SpanTexts_t());

    paraTexts.back().reserve(text[para].spans.size());

    for (unsigned i_spans = 0; i_spans != text[para].spans.size(); ++i_spans)

    {

      librevenge::RVNGString textString;

      appendCharacters(textString, text[para].spans[i_spans].chars, encoding);

      offset += textString.len();

      // TODO: why do we not drop these during parse already?

      if ((i_spans == text[para].spans.size() - 1) && (textString == "\r"))

        continue;

      paraTexts.back().push_back(textString);

    }

    assert(paraTexts.back().size() <= text[para].spans.size());

    if (offset >= tableCellTextEnds[paraToCellMap.size()])

    {

      if (offset > tableCellTextEnds[paraToCellMap.size()])

      {

        MSPUB_DEBUG_MSG(("text of cell %u ends in the middle of a paragraph!\n", unsigned(paraToCellMap.size())));

      }

      paraToCellMap.push_back(std::make_pair(firstPara, para));

      firstPara = para + 1;

    }

  }

  assert(paraTexts.size() == text.size());

  assert(paraToCellMap.size() <= tableCellTextEnds.size());

}

void fillUnderline(librevenge::RVNGPropertyList &props, const Underline underline)

{

  switch (underline)

  {

  case Underline::None:

    return;

  case Underline::Single:

  case Underline::WordsOnly:

  case Underline::Double:

  case Underline::Thick:

    props.insert("style:text-underline-style", "solid");

    break;

  case Underline::Dotted:

  case Underline::ThickDot:

    props.insert("style:text-underline-style", "dotted");

    break;

  case Underline::Dash:

  case Underline::ThickDash:

    props.insert("style:text-underline-style", "dash");

    break;

  case Underline::DotDash:

  case Underline::ThickDotDash:

    props.insert("style:text-underline-style", "dot-dash");

    break;

  case Underline::DotDotDash:

  case Underline::ThickDotDotDash:

    props.insert("style:text-underline-style", "dot-dot-dash");

    break;

  case Underline::Wave:

  case Underline::ThickWave:

  case Underline::DoubleWave:

    props.insert("style:text-underline-style", "wave");

    break;

  case Underline::LongDash:

  case Underline::ThickLongDash:

    props.insert("style:text-underline-style", "long-dash");

    break;

  }

  switch (underline)

  {

  case Underline::Double:

  case Underline::DoubleWave:

    props.insert("style:text-underline-type", "double");

    break;

  default:

    props.insert("style:text-underline-type", "single");

    break;

  }

  switch (underline)

  {

  case Underline::Thick:

  case Underline::ThickWave:

  case Underline::ThickDot:

  case Underline::ThickDash:

  case Underline::ThickDotDash:

  case Underline::ThickDotDotDash:

    props.insert("style:text-underline-width", "bold");

    break;

  default:

    props.insert("style:text-underline-width", "auto");

    break;

  }

  switch (underline)

  {

  case Underline::WordsOnly:

    props.insert("style:text-underline-mode", "skip-white-space");

    break;

  default:

    props.insert("style:text-underline-mode", "continuous");

    break;

  }

}

void fillLocale(librevenge::RVNGPropertyList &props, const unsigned lcid)

{

  char locale[ULOC_FULLNAME_CAPACITY];

  UErrorCode status = U_ZERO_ERROR;

  uloc_getLocaleForLCID(lcid, locale, ULOC_FULLNAME_CAPACITY, &status);

  if (!U_SUCCESS(status))

    return;

  char component[ULOC_FULLNAME_CAPACITY];

  int32_t len = uloc_getLanguage(locale, component, ULOC_FULLNAME_CAPACITY, &status);

  if (U_SUCCESS(status) && len > 0)

    props.insert("fo:language", component);

  len = uloc_getCountry(locale, component, ULOC_FULLNAME_CAPACITY, &status);

  if (U_SUCCESS(status) && len > 0)

    props.insert("fo:country", component);

  len = uloc_getScript(locale, component, ULOC_FULLNAME_CAPACITY, &status);

  if (U_SUCCESS(status) && len > 0)

    props.insert("fo:script", component);

}

} // anonymous namespace

void MSPUBCollector::collectMetaData(const librevenge::RVNGPropertyList &metaData)

{

  m_metaData = metaData;

}

void MSPUBCollector::addEOTFont(const librevenge::RVNGString &name, const librevenge::RVNGBinaryData &data)

{

  m_embeddedFonts.push_back(EmbeddedFontInfo(name, data));

}

void MSPUBCollector::setShapePictureRecolor(unsigned seqNum,

                                            const ColorReference &recolor)

{

  m_shapeInfosBySeqNum[seqNum].m_pictureRecolor = recolor;

}

void MSPUBCollector::setShapePictureBrightness(unsigned seqNum,

                                               int brightness)

{

  m_shapeInfosBySeqNum[seqNum].m_pictureBrightness = brightness;

}

void MSPUBCollector::setShapePictureContrast(unsigned seqNum,

                                             int contrast)

{

  m_shapeInfosBySeqNum[seqNum].m_pictureContrast = contrast;

}

void MSPUBCollector::setShapeBeginArrow(unsigned seqNum,

                                        const Arrow &arrow)

{

  m_shapeInfosBySeqNum[seqNum].m_beginArrow = arrow;

}

void MSPUBCollector::setShapeVerticalTextAlign(unsigned seqNum,

                                               VerticalAlign va)

{

  m_shapeInfosBySeqNum[seqNum].m_verticalAlign = va;

}

void MSPUBCollector::setShapeEndArrow(unsigned seqNum,

                                      const Arrow &arrow)

{

  m_shapeInfosBySeqNum[seqNum].m_endArrow = arrow;

}

void MSPUBCollector::setShapeTableInfo(unsigned seqNum,

                                       const TableInfo &ti)

{

  m_shapeInfosBySeqNum[seqNum].m_tableInfo = ti;

}

void MSPUBCollector::setShapeNumColumns(unsigned seqNum,

                                        unsigned numColumns)

{

  m_shapeInfosBySeqNum[seqNum].m_numColumns = numColumns;

}

void MSPUBCollector::setShapeColumnSpacing(unsigned seqNum,

                                           unsigned spacing)

{

  m_shapeInfosBySeqNum[seqNum].m_columnSpacing = spacing;

}

void MSPUBCollector::setShapeStretchBorderArt(unsigned seqNum)

{

  m_shapeInfosBySeqNum[seqNum].m_stretchBorderArt = true;

}

void MSPUBCollector::setRectCoordProps(Coordinate coord, librevenge::RVNGPropertyList *props) const

{

  props->insert("svg:x", coord.getXIn(m_width));

  props->insert("svg:y", coord.getYIn(m_height));

  props->insert("svg:width", coord.getWidthIn());

  props->insert("svg:height", coord.getHeightIn());

}

Coordinate getFudgedCoordinates(Coordinate coord, const std::vector<Line> &lines, bool makeBigger, BorderPosition borderPosition)

{

  Coordinate fudged = coord;

  unsigned topFudge = 0;

  unsigned rightFudge = 0;

  unsigned bottomFudge = 0;

  unsigned leftFudge = 0;

  switch (borderPosition)

  {

  case HALF_INSIDE_SHAPE:

    topFudge = (!lines.empty()) ? lines[0].m_widthInEmu / 2 : 0;

    rightFudge = (lines.size() > 1) ? lines[1].m_widthInEmu / 2 : 0;

    bottomFudge = (lines.size() > 2) ? lines[2].m_widthInEmu / 2 : 0;

    leftFudge = (lines.size() > 3) ? lines[3].m_widthInEmu / 2 : 0;

    break;

  case OUTSIDE_SHAPE:

    topFudge = (!lines.empty()) ? lines[0].m_widthInEmu : 0;

    rightFudge = (lines.size() > 1) ? lines[1].m_widthInEmu : 0;

    bottomFudge = (lines.size() > 2) ? lines[2].m_widthInEmu : 0;

    leftFudge = (lines.size() > 3) ? lines[3].m_widthInEmu : 0;

    break;

  case INSIDE_SHAPE:

  default:

    break;

  }

  if (makeBigger)

  {

    fudged.m_xs -= leftFudge;

    fudged.m_xe += rightFudge;

    fudged.m_ys -= topFudge;

    fudged.m_ye += bottomFudge;

  }

  else

  {

    fudged.m_xs += leftFudge;

    fudged.m_xe -= rightFudge;

    fudged.m_ys += topFudge;

    fudged.m_ye -= bottomFudge;

  }

  return fudged;

}

void MSPUBCollector::setNextPage(unsigned pageSeqNum)

{

  m_pageSeqNumsOrdered.push_back(pageSeqNum);

}

MSPUBCollector::MSPUBCollector(librevenge::RVNGDrawingInterface *painter) :

  m_painter(painter), m_contentChunkReferences(), m_width(0), m_height(0),

  m_widthSet(false), m_heightSet(false),

  m_numPages(0), m_textStringsById(), m_pagesBySeqNum(),

  m_images(), m_borderImages(),

  m_textColors(), m_fonts(),

  m_defaultCharStyles(), m_defaultParaStyles(), m_shapeTypesBySeqNum(),

  m_paletteColors(), m_shapeSeqNumsOrdered(),

  m_pageSeqNumsByShapeSeqNum(), m_bgShapeSeqNumsByPageSeqNum(),

  m_skipIfNotBgSeqNums(),

  m_currentShapeGroup(), m_topLevelShapes(),

  m_groupsBySeqNum(), m_embeddedFonts(),

  m_shapeInfosBySeqNum(), m_masterPages(),

  m_shapesWithCoordinatesRotated90(),

  m_masterPagesByPageSeqNum(),

  m_tableCellTextEndsByTextId(), m_stringOffsetsByTextId(),

  m_calculationValuesSeen(), m_pageSeqNumsOrdered(),

  m_encodingHeuristic(false), m_allText(),

  m_calculatedEncoding(),

  m_metaData()

{

}

void MSPUBCollector::setTextStringOffset(

  unsigned textId, unsigned offset)

{

  m_stringOffsetsByTextId[textId] = offset;

}

void MSPUBCollector::setTableCellTextEnds(

  const unsigned textId, const std::vector<unsigned> &ends)

{

  m_tableCellTextEndsByTextId[textId] = ends;

}

void MSPUBCollector::useEncodingHeuristic()

{

  m_encodingHeuristic = true;

}

void MSPUBCollector::setShapeShadow(unsigned seqNum, const Shadow &shadow)

{

  m_shapeInfosBySeqNum[seqNum].m_shadow = shadow;

}

void noop(const CustomShape *)

{

}

void MSPUBCollector::setShapeCoordinatesRotated90(unsigned seqNum)

{

  m_shapesWithCoordinatesRotated90.insert(seqNum);

}

void MSPUBCollector::setShapeBorderImageId(unsigned seqNum, unsigned id)

{

  m_shapeInfosBySeqNum[seqNum].m_borderImgIndex = id;

}

void MSPUBCollector::setShapeCustomPath(unsigned seqNum,

                                        const DynamicCustomShape &shape)

{

  m_shapeInfosBySeqNum[seqNum].m_customShape = shape;

}

void MSPUBCollector::setShapeClipPath(unsigned seqNum, const std::vector<Vertex> &clip)

{

  m_shapeInfosBySeqNum[seqNum].m_clipPath = clip;

}

void MSPUBCollector::beginGroup()

{

  auto tmp = ShapeGroupElement::create(m_currentShapeGroup);

  if (!m_currentShapeGroup)

  {

    m_topLevelShapes.push_back(tmp);

  }

  m_currentShapeGroup = tmp;

}

bool MSPUBCollector::endGroup()

{

  if (!m_currentShapeGroup)

  {

    return false;

  }

  m_currentShapeGroup = m_currentShapeGroup->getParent();

  return true;

}

void MSPUBCollector::addShapeLine(unsigned seqNum, Line line)

{

  m_shapeInfosBySeqNum[seqNum].m_lines.push_back(line);

}

void MSPUBCollector::setShapeBorderPosition(unsigned seqNum, BorderPosition pos)

{

  m_shapeInfosBySeqNum[seqNum].m_borderPosition = pos;

}

bool MSPUBCollector::hasPage(unsigned seqNum) const

{

  return m_pagesBySeqNum.find(seqNum) != m_pagesBySeqNum.end();

}

void MSPUBCollector::setShapeMargins(unsigned seqNum, unsigned left, unsigned top, unsigned right, unsigned bottom)

{

  m_shapeInfosBySeqNum[seqNum].m_margins = Margins(left, top, right, bottom);

}

void MSPUBCollector::setPageBgShape(unsigned pageSeqNum, unsigned seqNum)

{

  m_bgShapeSeqNumsByPageSeqNum[pageSeqNum] = seqNum;

}

bool MSPUBCollector::setCurrentGroupSeqNum(unsigned seqNum)

{

  if (!m_currentShapeGroup)

  {

    return false;

  }

  m_currentShapeGroup->setSeqNum(seqNum);

  m_groupsBySeqNum.insert(std::make_pair(seqNum, m_currentShapeGroup));

  return true;

}

void MSPUBCollector::setShapeOrder(unsigned seqNum)

{

  auto tmp = ShapeGroupElement::create(m_currentShapeGroup, seqNum);

  if (!m_currentShapeGroup)

  {

    m_topLevelShapes.push_back(tmp);

  }

}

void MSPUBCollector::addPaletteColor(Color c)

{

  m_paletteColors.push_back(c);

}

void no_op()

{

}

void endShapeGroup(librevenge::RVNGDrawingInterface *painter)

{

  painter->endLayer();

}

std::vector<int> MSPUBCollector::getShapeAdjustValues(const ShapeInfo &info) const

{

  std::vector<int> ret;

  std::shared_ptr<const CustomShape> ptr_shape = info.getCustomShape();

  if (ptr_shape)

  {

    for (unsigned i = 0; i < ptr_shape->m_numDefaultAdjustValues; ++i)

    {

      ret.push_back(ptr_shape->mp_defaultAdjustValues[i]);

    }

  }

  for (auto i = info.m_adjustValuesByIndex.begin(); i != info.m_adjustValuesByIndex.end(); ++i)

  {

    unsigned index = i->first;

    int adjustVal = i->second;

    for (unsigned j = info.m_adjustValues.size(); j <= index; ++j)

    {

      ret.push_back(0);

    }

    ret[index] = adjustVal;

  }

  return ret;

}

boost::optional<std::vector<TextParagraph> > MSPUBCollector::getShapeText(const ShapeInfo &info) const

{

  if (bool(info.m_textId))

  {

    unsigned stringId = info.m_textId.get();

    const std::vector<TextParagraph> *ptr_str = getIfExists_const(m_textStringsById, stringId);

    if (ptr_str)

    {

      return *ptr_str;

    }

  }

  return boost::optional<std::vector<TextParagraph> >();

}

void MSPUBCollector::setupShapeStructures(ShapeGroupElement &elt)

{

  ShapeInfo *ptr_info = getIfExists(m_shapeInfosBySeqNum, elt.getSeqNum());

  if (ptr_info)

  {

    if (bool(ptr_info->m_imgIndex))

    {

      unsigned index = ptr_info->m_imgIndex.get();

      int rot = 0;

      if (bool(ptr_info->m_innerRotation))

        rot = ptr_info->m_innerRotation.get();

      if (index - 1 < m_images.size())

      {

        ptr_info->m_fill = std::shared_ptr<const Fill>(new ImgFill(index, this, false, rot));

      }

    }

    elt.setShapeInfo(*ptr_info);

    std::pair<bool, bool> flips = ptr_info->m_flips.get_value_or(std::pair<bool, bool>(false, false));

    VectorTransformation2D flipsTransform = VectorTransformation2D::fromFlips(flips.second, flips.first);

    double rotation = ptr_info->m_rotation.get_value_or(0);

    rotation = doubleModulo(rotation, 360);

    bool rotBackwards = flips.first ^ flips.second;

    VectorTransformation2D rot = VectorTransformation2D::fromCounterRadians((rotBackwards ? -rotation : rotation) * M_PI / 180);

    elt.setTransform(rot * flipsTransform);

  }

}

std::function<void(void)> MSPUBCollector::paintShape(const ShapeInfo &info, const Coordinate &/* relativeTo*/, const VectorTransformation2D &foldedTransform, bool isGroup, const VectorTransformation2D &thisTransform) const

{

  std::vector<int> adjustValues = getShapeAdjustValues(info);

  if (isGroup)

  {

    m_painter->startLayer(librevenge::RVNGPropertyList());

    return std::bind(&endShapeGroup, m_painter);

  }

  librevenge::RVNGPropertyList graphicsProps;

  if (info.m_fill)

  {

    info.m_fill->getProperties(&graphicsProps);

  }

  bool hasStroke = false;

  bool hasBorderArt = false;

  boost::optional<unsigned> maybeBorderImg = info.m_borderImgIndex;

  if (bool(maybeBorderImg) && !info.m_lines.empty())

  {

    hasStroke = true;

    hasBorderArt = true;

  }

  else

  {

    for (const auto &line : info.m_lines)

    {

      hasStroke = hasStroke || line.m_lineExists;

      if (hasStroke)

      {

        break;

      }

    }

  }

  librevenge::RVNGString fill = graphicsProps["draw:fill"] ? graphicsProps["draw:fill"]->getStr() : "none";

  bool hasFill = fill != "none";

  boost::optional<std::vector<TextParagraph> > maybeText = getShapeText(info);

  auto hasText = bool(maybeText);

  const auto isTable = bool(info.m_tableInfo);

  bool makeLayer = hasBorderArt ||

                   (hasStroke && hasFill) || (hasStroke && hasText) || (hasFill && hasText);

  if (makeLayer)

  {

    if (info.m_clipPath.size() > 0)

    {

      const Coordinate coord = info.m_coordinates.get_value_or(Coordinate());

      double x, y, height, width;

      x = coord.getXIn(m_width);

      y = coord.getYIn(m_height);

      height = coord.getHeightIn();

      width = coord.getWidthIn();

      m_painter->startLayer(calcClipPath(info.m_clipPath, x, y, height, width, foldedTransform, info.getCustomShape()));

    }

    else

      m_painter->startLayer(librevenge::RVNGPropertyList());

  }

  graphicsProps.insert("draw:stroke", "none");

  const Coordinate coord = info.m_coordinates.get_value_or(Coordinate());

  BorderPosition borderPosition =

    hasBorderArt ? INSIDE_SHAPE : info.m_borderPosition.get_value_or(HALF_INSIDE_SHAPE);

  ShapeType type;

  if (bool(info.m_cropType))

  {

    type = info.m_cropType.get();

  }

  else

  {

    type = info.m_type.get_value_or(RECTANGLE);

  }

  if (hasFill)

  {

    double x, y, height, width;

    x = coord.getXIn(m_width);

    y = coord.getYIn(m_height);

    height = coord.getHeightIn();

    width = coord.getWidthIn();

    if (hasBorderArt)

    {

      double borderImgWidth =

        static_cast<double>(info.m_lines[0].m_widthInEmu) / EMUS_IN_INCH;

      if (height > 2 * borderImgWidth && width >= 2 * borderImgWidth)

      {

        x += borderImgWidth;

        y += borderImgWidth;

        height -= 2 * borderImgWidth;

        width -= 2 * borderImgWidth;

      }

    }

    if (bool(info.m_pictureRecolor))

    {

      Color obc = info.m_pictureRecolor.get().getFinalColor(m_paletteColors);

      graphicsProps.insert("draw:color-mode", "greyscale");

      graphicsProps.insert("draw:red",

                           static_cast<double>(obc.r) / 255.0, librevenge::RVNG_PERCENT);

      graphicsProps.insert("draw:blue",

                           static_cast<double>(obc.b) / 255.0, librevenge::RVNG_PERCENT);

      graphicsProps.insert("draw:green",

                           static_cast<double>(obc.g) / 255.0, librevenge::RVNG_PERCENT);

    }

    if (bool(info.m_pictureBrightness))

      graphicsProps.insert("draw:luminance", static_cast<double>(info.m_pictureBrightness.get() + 32768.0) / 65536.0, librevenge::RVNG_PERCENT);

    bool shadowPropsInserted = false;

    if (bool(info.m_shadow))

    {

      const Shadow &s = info.m_shadow.get();

      if (!needsEmulation(s))

      {

        shadowPropsInserted = true;

        graphicsProps.insert("draw:shadow", "visible");

        graphicsProps.insert("draw:shadow-offset-x", static_cast<double>(s.m_offsetXInEmu) / EMUS_IN_INCH);

        graphicsProps.insert("draw:shadow-offset-y", static_cast<double>(s.m_offsetYInEmu) / EMUS_IN_INCH);

        graphicsProps.insert("draw:shadow-color", getColorString(s.m_color.getFinalColor(m_paletteColors)));

        graphicsProps.insert("draw:shadow-opacity", s.m_opacity, librevenge::RVNG_PERCENT);

      }

      // TODO: Emulate shadows that don't conform

      // to LibreOffice's range of possible shadows.

    }

    m_painter->setStyle(graphicsProps);

    writeCustomShape(type, graphicsProps, m_painter, x, y, height, width,

                     true, foldedTransform,

                     std::vector<Line>(), std::bind(&MSPUBCollector::getCalculationValue, this, info, _1, false, adjustValues), m_paletteColors, info.getCustomShape());

    if (bool(info.m_pictureRecolor))

    {

      graphicsProps.remove("draw:color-mode");

      graphicsProps.remove("draw:red");

      graphicsProps.remove("draw:blue");

      graphicsProps.remove("draw:green");

    }

    if (bool(info.m_pictureBrightness))

      graphicsProps.remove("draw:luminance");

    if (shadowPropsInserted)

    {

      graphicsProps.remove("draw:shadow");

      graphicsProps.remove("draw:shadow-offset-x");

      graphicsProps.remove("draw:shadow-offset-y");

      graphicsProps.remove("draw:shadow-color");

      graphicsProps.remove("draw:shadow-opacity");

    }

  }

  const std::vector<Line> &lines = info.m_lines;

  if (hasStroke)

  {

    if (hasBorderArt && lines[0].m_widthInEmu > 0)

    {

      bool stretch = info.m_stretchBorderArt;

      double x = coord.getXIn(m_width);

      double y = coord.getYIn(m_height);

      double height = coord.getHeightIn();

      double width = coord.getWidthIn();

      double borderImgWidth =

        static_cast<double>(info.m_lines[0].m_widthInEmu) / EMUS_IN_INCH;

      auto numImagesHoriz = static_cast<unsigned>(width / borderImgWidth);

      auto numImagesVert = static_cast<unsigned>(height / borderImgWidth);

      double borderVertTotalPadding = height - numImagesVert * borderImgWidth;

      double borderHorizTotalPadding = width - numImagesHoriz * borderImgWidth;

      if (numImagesHoriz >= 2 && numImagesVert >= 2)

      {

        auto numStretchedImagesVert = static_cast<unsigned>(0.5 + (height - 2 * borderImgWidth) / borderImgWidth);

        auto numStretchedImagesHoriz = static_cast<unsigned>(0.5 + (width - 2 * borderImgWidth) / borderImgWidth);

        double stretchedImgHeight = stretch ?

                                    (height - 2 * borderImgWidth) / numStretchedImagesVert :

                                    borderImgWidth;

        double stretchedImgWidth = stretch ?

                                   (width - 2 * borderImgWidth) / numStretchedImagesHoriz :

                                   borderImgWidth;

        if (stretch)

        {

          numImagesVert = 2 + numStretchedImagesVert;

          numImagesHoriz = 2 + numStretchedImagesHoriz;

        }

        double borderVertPadding = borderVertTotalPadding / (numImagesVert - 1);

        double borderHorizPadding = borderHorizTotalPadding / (numImagesHoriz - 1);

        if (maybeBorderImg.get() < m_borderImages.size())

        {

          const BorderArtInfo &ba = m_borderImages[maybeBorderImg.get()];

          if (!ba.m_offsets.empty())

          {

            librevenge::RVNGPropertyList baProps;

            baProps.insert("draw:stroke", "none");

            baProps.insert("draw:fill", "solid");

            baProps.insert("draw:fill-color", "#ffffff");

            m_painter->setStyle(baProps);

            librevenge::RVNGPropertyList topRectProps;

            topRectProps.insert("svg:x", x);

            topRectProps.insert("svg:y", y);

            topRectProps.insert("svg:height", borderImgWidth);

            topRectProps.insert("svg:width", width);

            m_painter->drawRectangle(topRectProps);

            librevenge::RVNGPropertyList rightRectProps;

            rightRectProps.insert("svg:x", x + width - borderImgWidth);

            rightRectProps.insert("svg:y", y);