/* -*- Mode: C++; c-default-style: "k&r"; indent-tabs-mode: nil; tab-width: 2; c-basic-offset: 2 -*- */

/* libmwaw

* Version: MPL 2.0 / LGPLv2+

*

* The contents of this file are subject to the Mozilla Public License Version

* 2.0 (the "License"); you may not use this file except in compliance with

* the License or as specified alternatively below. You may obtain a copy of

* the License at http://www.mozilla.org/MPL/

*

* Software distributed under the License is distributed on an "AS IS" basis,

* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License

* for the specific language governing rights and limitations under the

* License.

*

* Major Contributor(s):

* Copyright (C) 2002 William Lachance (wrlach@gmail.com)

* Copyright (C) 2002,2004 Marc Maurer (uwog@uwog.net)

* Copyright (C) 2004-2006 Fridrich Strba (fridrich.strba@bluewin.ch)

* Copyright (C) 2006, 2007 Andrew Ziem

* Copyright (C) 2011, 2012 Alonso Laurent (alonso@loria.fr)

*

*

* All Rights Reserved.

*

* For minor contributions see the git repository.

*

* Alternatively, the contents of this file may be used under the terms of

* the GNU Lesser General Public License Version 2 or later (the "LGPLv2+"),

* in which case the provisions of the LGPLv2+ are applicable

* instead of those above.

*/

#include <cmath>

#include <iomanip>

#include <iostream>

#include <limits>

#include <set>

#include <sstream>

#include <stack>

#include <utility>

#include <librevenge/librevenge.h>

#include "MWAWFontConverter.hxx"

#include "MWAWGraphicListener.hxx"

#include "MWAWGraphicStyle.hxx"

#include "MWAWHeader.hxx"

#include "MWAWPosition.hxx"

#include "MWAWPrinter.hxx"

#include "MWAWRSRCParser.hxx"

#include "MWAWStringStream.hxx"

#include "CanvasGraph.hxx"

#include "CanvasStyleManager.hxx"

#include "CanvasParser.hxx"

/** Internal: the structures of a CanvasParser */

namespace CanvasParserInternal

{

//! Internal: the layer of a CanvasParser

struct Layer {

  //! constructor

  Layer()

    : m_name()

    , m_numShapes()

    , m_shapesId()

  {

  }

  //! the layer name

  librevenge::RVNGString m_name;

  //! the number of shape

  int m_numShapes;

  //! the shape id

  std::vector<int> m_shapesId;

};

////////////////////////////////////////

//! Internal and low level: the decoder of a canvas file

struct Decoder {

  //! constructor

  Decoder()

    : m_version(2)

    , m_isWindows(false)

    , m_input()

    , m_inputPos(0)

    , m_stream()

  {

  }

  //! first function to init the output (and copy the first headerSize characters)

  bool initOutput(MWAWInputStreamPtr &input, unsigned long const headerSize=0x89c);

  //! returns true if the input is completly decoded

  bool isEnd() const

  {

    return m_inputPos>=m_input->size();

  }

  //! try to read the following sz bytes and append them to the output

  bool append(long length);

  //! try to decode a part of the input

  bool decode(long length=-1);

  //! try to decode a part of the input: v3

  bool decode3(long length);

  //! try to unpack some bits from buffer into buffer2, assuming buffer and buffer2 differs

  bool unpackBits(unsigned char const(&buffer)[256], int n,

                  unsigned char (&buffer2)[256], int &n2) const;

  //! the file version

  int m_version;

  //! a flag to know if the file is a windows file

  bool m_isWindows;

  //! the initial input

  MWAWInputStreamPtr m_input;

  //! the input current position

  long m_inputPos;

  //! the current stream

  std::shared_ptr<MWAWStringStream> m_stream;

};

bool Decoder::unpackBits(unsigned char const(&buffer)[256], int n,

                         unsigned char (&buffer2)[256], int &n2) const

{

  if (n<=0 || n>256 || &buffer == &buffer2) {

    MWAW_DEBUG_MSG(("CanvasParserInternal::Decoder::unpackBits: bad arguments\n"));

    return false;

  }

  int r=0;

  n2=0;

  // canvas only packs zone with less than 127 characters

  // => we must not found <M> M+1 bits <N> N+1 bits

  bool lastCopy=false;

  while (r+1<n) {

    int c=buffer[r++];

    if (c>=0x81) {

      unsigned char val=buffer[r++];

      int num=0x101-c;

      if (n2+num>256)

        return false;

      for (int i=0; i<num; ++i)

        buffer2[n2++]=val;

      lastCopy=false;

    }

    else {

      // normally c==0x80 is reserved, but must not be used

      if (lastCopy && !m_isWindows)

        return false;

      int num=c+1;

      if (r+num>n || n2+num>256)

        return false;

      for (int i=0; i<num; ++i)

        buffer2[n2++]=buffer[r++];

      lastCopy=true;

    }

  }

  return r==n;

}

bool Decoder::initOutput(MWAWInputStreamPtr &input, unsigned long const headerSize)

{

  m_input=input;

  if (!m_input || !m_input->checkPosition(long(headerSize)+20)) {

    MWAW_DEBUG_MSG(("CanvasParserInternal::Decoder::initOutput: can not find the input\n"));

    return false;

  }

  m_input->seek(0, librevenge::RVNG_SEEK_SET);

  unsigned long read;

  const unsigned char *dt = m_input->read(headerSize, read);

  if (!dt || read != headerSize) {

    MWAW_DEBUG_MSG(("CanvasParserInternal::Decoder::initOutput: can not read some data\n"));

    return false;

  }

  m_stream.reset(new MWAWStringStream(dt, unsigned(headerSize)));

  m_inputPos=long(headerSize);

  return true;

}

bool Decoder::append(long length)

{

  if (length==0)

    return true;

  if (!m_input || !m_stream || length<0 || !m_input->checkPosition(m_input->tell()+length)) {

    MWAW_DEBUG_MSG(("CanvasParserInternal::Decoder::append: the zone seems too short\n"));

    return false;

  }

  auto actIPos=m_input->tell();

  auto actOPos=m_stream->tell();

  m_input->seek(m_inputPos, librevenge::RVNG_SEEK_SET);

  m_stream->seek(0, librevenge::RVNG_SEEK_END);

  unsigned long read;

  const unsigned char *dt = m_input->read((unsigned long)length, read);

  bool ok=true;

  if (!dt || read != (unsigned long)length) {

    MWAW_DEBUG_MSG(("CanvasParserInternal::Decoder::append: can not read some data\n"));

    ok=false;

  }

  if (ok) {

    m_stream->append(dt, unsigned(length));

    m_inputPos=m_input->tell();

  }

  m_input->seek(actIPos, librevenge::RVNG_SEEK_SET);

  m_stream->seek(actOPos, librevenge::RVNG_SEEK_SET);

  return ok;

}

bool Decoder::decode(long length)

{

  if (!m_input || !m_stream) {

    MWAW_DEBUG_MSG(("CanvasParserInternal::Decoder::decode: can not find the input/output\n"));

    return false;

  }

  auto actIPos=m_input->tell();

  auto actOPos=m_stream->tell();

  m_input->seek(m_inputPos, librevenge::RVNG_SEEK_SET);

  m_stream->seek(0, librevenge::RVNG_SEEK_END);

  long lastPos=m_input->size();

  bool ok=true;

  if (m_inputPos>=lastPos)

    ok=false;

  if (m_version<=2) {

    long nWrite=0;

    unsigned char data[256], data2[256];

    while (ok && !m_input->isEnd()) {

      if (length>=0 && nWrite>=length)

        break;

      long pos=m_input->tell();

      int zSz=int(m_input->readULong(1));

      long endPos=pos+zSz;

      if (zSz==0 || endPos>lastPos) {

        MWAW_DEBUG_MSG(("CanvasParserInternal::Decoder::decode: can not read some data zSz=%d, pos=%lx\n", zSz, (unsigned long) pos));

        ok=false;

        break;

      }

      for (int i=0; i<zSz; ++i) data[i]=(unsigned char)(m_input->readULong(1));

      int n;

      if (!unpackBits(data, zSz, data2, n)) {

        MWAW_DEBUG_MSG(("CanvasParserInternal::Decoder::decode: can not read some data at %lx\n", (unsigned long) pos));

        ok=false;

        break;

      }

      m_stream->append(data2, static_cast<unsigned int>(n));

      nWrite+=n;

    }

    if (ok && length>=0 && nWrite!=length) {

      MWAW_DEBUG_MSG(("CanvasParserInternal::Decoder::decode: can not decode some data\n"));

      ok=false;

    }

  }

  else if (ok)

    ok=decode3(length);

  if (ok)

    m_inputPos=m_input->tell();

  m_input->seek(actIPos, librevenge::RVNG_SEEK_SET);

  m_stream->seek(actOPos, librevenge::RVNG_SEEK_SET);

  return ok;

}

#ifdef DEBUG_WITH_FILES

// flag to debug/or not the uncompress function

static bool s_showData=false;

#endif

bool Decoder::decode3(long length)

{

  if (!m_input || !m_stream) {

    MWAW_DEBUG_MSG(("CanvasParserInternal::Decoder::decode3: can not find the input/output\n"));

    return false;

  }

  long lastPos=m_input->size();

  long numWrite=0;

  int const maxFinalSize=120;

  unsigned char data[256], data2[256];

  bool forceDict=false;

  unsigned char m_dict[30];

  std::set<unsigned char> m_dictKeys;

  bool m_isDictInitialized=false;

  long lastDictPos=0;

  // a zone is stored:

  // - either as a list of [length] packbits [checksum]

  // - or as a dictionary (30 keys) and a list of [length] bytes where bytes can be:

  //    . packbits [checksum] as before

  //    . or compressed with dictionary of (packbits [checksum])

  // I supposed that the dictionary is only created if the zone's length is greated than a constant (to be verified).

  // There remains also the problem to know if (packbits [checksum]) has been compressed with the dictionary or not ;

  //   currently, I test if I can decode these sub zones with the dictionary, ...

  while (m_input->tell()<lastPos) {

    if (length>=0 && numWrite>=length)

      return numWrite==length;

    long pos=m_input->tell();

    int zSz=int(m_input->readULong(1));

    // FIXME: find a method to detect if the zone begins with a dictionary, maybe length>some constant

    if ((length<0 || numWrite==0) && lastDictPos+30!=pos && (zSz<2 || zSz>maxFinalSize+3 || forceDict)) {

      if (pos+30>lastPos) {

        MWAW_DEBUG_MSG(("CanvasParserInternal::Decoder::decode3: can not read a dictionary at pos=%lx\n", (unsigned long) pos));

        return false;

      }

      // create the dictionary

      lastDictPos=pos;

      m_dict[0]=(unsigned char)(zSz);

      for (int i=1; i<30; ++i)

        m_dict[i]=(unsigned char)m_input->readULong(1);

      m_dictKeys.clear();

      for (auto &c : m_dict) m_dictKeys.insert(c);

      m_isDictInitialized=true;

      forceDict=false;

      continue;

    }

    else if (forceDict) {

      MWAW_DEBUG_MSG(("CanvasParserInternal::Decoder::decode3: can not place a dictionary at pos=%lx\n", (unsigned long) pos));

      return false;

    }

    long endPos=pos+1+zSz;

    if (endPos>lastPos) {

      MWAW_DEBUG_MSG(("CanvasParserInternal::Decoder::decode3: force a dictionary in pos=%lx\n", (unsigned long) pos));

      forceDict=true;

      m_input->seek(pos, librevenge::RVNG_SEEK_SET);

      continue;

    }

    // FIXME: find a method if the data are compressed or not

    int const lastChecksumSz=m_isWindows ? 1 : 0;

    for (int step=0; step<3; ++step) {

      if (step==2) {

        MWAW_DEBUG_MSG(("CanvasParserInternal::Decoder::decode3: force a dictionary in pos=%lx\n", (unsigned long) pos));

        forceDict=true;

        m_input->seek(pos, librevenge::RVNG_SEEK_SET);

        break;

      }

      m_input->seek(pos+1, librevenge::RVNG_SEEK_SET);

      int numChar=int(m_input->readULong(1));

#ifdef DEBUG_WITH_FILES

      int nChar=numChar;

#endif

      if (step==0) {

        if (!m_isDictInitialized || zSz>numChar || numChar>2*zSz || numChar>maxFinalSize+2+lastChecksumSz) continue;

        // try to decode with the dictionary has been used to pack the data

        bool ok=true;

        int w=0;

        unsigned char c;

        bool readC=false;

        while (m_input->tell()<=endPos && w<numChar) {

          int newC=0;

          for (int st=0; st<4; ++st) {

            int val;

            if (!readC) {

              if (m_input->tell()>endPos) {

                ok=false;

                break;

              }

              c=(unsigned char) m_input->readULong(1);

              val=int(c>>4);

            }

            else

              val=int(c&0xf);

            readC=!readC;

            if (val && st<2) {

              data[w++]=m_dict[15*st+val-1];

              break;

            }

            newC=(newC<<4)|val;

            if (st==3) {

              if (m_dictKeys.find((unsigned char) newC)!=m_dictKeys.end()) {

                ok=false;

                break;

              }

              data[w++]=(unsigned char) newC;

            }

          }

          if (ok==false)

            break;

        }

        if (ok==false || w!=numChar || m_input->tell()<endPos)

          continue;

      }

      else {

        // basic copy

        // checkme: on mac, the first bytes is always ignored when numChar+1==zSz ;

        //          but only sometimes on windows :-~

        if (numChar+1!=zSz) {

          m_input->seek(-1, librevenge::RVNG_SEEK_CUR);

          numChar=zSz;

        }

        for (int i=0; i<numChar; ++i)

          data[i]=(unsigned char) m_input->readULong(1);

      }

      // first check the checksum

      int checkSum;

      bool ok=false;

      for (int step2=0; step2<2; ++step2) {

        if (step2==1) {

          if (!m_isWindows || step!=1 || numChar+1!=zSz)

            break;

          m_input->seek(-zSz, librevenge::RVNG_SEEK_CUR);

          numChar=zSz;

          for (int i=0; i<numChar; ++i)

            data[i]=(unsigned char) m_input->readULong(1);

        }

        checkSum=0;

        for (int i=0; i<numChar-1; ++i)

          checkSum+=int(data[i]);

        if (numChar==0 || (checkSum&0xff)!=int(data[numChar-1]))

          continue;

        ok=true;

        break;

      }

      if (!ok) continue;

      --numChar;

#ifdef DEBUG_WITH_FILES

      if (s_showData) {

        std::cout << zSz << "[" << nChar << "," << numChar << "]:";

        auto prev=std::cout.fill('0');

        for (int i=0; i < numChar; ++i)

          std::cout << std::hex << std::setw(2) << int(data[i]) << std::dec;

        std::cout.fill(prev);

        std::cout << "\n";

      }

#endif

      // then check if we can unpack the data

      int finalN;

      if (!unpackBits(data, numChar, data2, finalN) || finalN>maxFinalSize+lastChecksumSz || (m_isWindows && finalN<=numChar) ||

          (length>=0 && numWrite+finalN>length+lastChecksumSz) || finalN<1+lastChecksumSz) {

        if (m_isWindows && (length<0 || numWrite+numChar<=length+lastChecksumSz) &&

            numChar<=maxFinalSize+lastChecksumSz && numChar>=1+lastChecksumSz) {

          for (int i=0; i < numChar; ++i)

            data2[i]=data[i];

          finalN=numChar;

        }

        else

          continue;

      }

#ifdef DEBUG_WITH_FILES

      if (s_showData) {

        std::cout << "\t" << finalN << ":";

        auto prev=std::cout.fill('0');

        for (int i=0; i < finalN; ++i)

          std::cout << std::hex << std::setw(2) << int(data2[i]) << std::dec;

        std::cout.fill(prev);

        std::cout << "\n";

      }

#endif

      if (lastChecksumSz==1) {

        checkSum=0;

        for (int i=0; i<finalN-1; ++i)

          checkSum+=int(data2[i]);

        if ((checkSum&0xff)!=int(data2[finalN-1]))

          continue;

        --finalN;

      }

      m_stream->append(data2, static_cast<unsigned int>(finalN));

      numWrite+=finalN;

      break;

    }

  }

  return length<0 || numWrite==length;

}

////////////////////////////////////////

//! Internal: the state of a CanvasParser

struct State {

  //! constructor

  State()

    : m_isWindowsFile(false)

    , m_lengths()

    , m_brushLengths()

    , m_bitmapSize(0)

    , m_input()

    , m_decoder()

    , m_numLayers(1)

    , m_numShapes(0)

    , m_numViews(0)

    , m_numColors(256) // FIXME: check if this number is stored in the file or not

    , m_numPatterns(120)

    , m_sprayLengths()

    , m_numPages(1,1)

    , m_pageDimension(425, 624)

    , m_layers()

    , m_metaData()

  {

  }

  //! true if this is a windows file

  bool m_isWindowsFile;

  //! the file header first 4+1 lengths

  std::vector<unsigned long> m_lengths;

  //! the brush lengths

  std::vector<unsigned long> m_brushLengths;

  //! the file bitmap size (Windows v3)

  long m_bitmapSize;

  //! the uncompressed input

  MWAWInputStreamPtr m_input;

  //! the main decoder

  Decoder m_decoder;

  //! the number of layer

  int m_numLayers;

  //! the number of shapes

  int m_numShapes;

  //! the number of views

  int m_numViews;

  //! the number of colors

  int m_numColors;

  //! the number of patterns

  int m_numPatterns;

  //! the list of spray size

  std::vector<unsigned long> m_sprayLengths;

  //! the number of pages

  MWAWVec2i m_numPages;

  //! the page dimension

  MWAWVec2i m_pageDimension;

  //! the layer

  std::vector<Layer> m_layers;

  //! the meta data

  librevenge::RVNGPropertyList m_metaData;

};

}

////////////////////////////////////////////////////////////

// constructor/destructor, ...

////////////////////////////////////////////////////////////

CanvasParser::CanvasParser(MWAWInputStreamPtr const &input, MWAWRSRCParserPtr const &rsrcParser, MWAWHeader *header)

  : MWAWGraphicParser(input, rsrcParser, header)

  , m_state()

  , m_graphParser()

  , m_styleManager()

{

  resetGraphicListener();

  setAsciiName("main-1");

  m_state.reset(new CanvasParserInternal::State);

  m_styleManager.reset(new CanvasStyleManager(*this));

  m_graphParser.reset(new CanvasGraph(*this));

  getPageSpan().setMargins(0.1);

}

CanvasParser::~CanvasParser()

{

}

MWAWInputStreamPtr &CanvasParser::getInput()

{

  if (m_state->m_input)

    return m_state->m_input;

  return MWAWGraphicParser::getInput();

}

bool CanvasParser::decode(long length)

{

  long prevSize=m_state->m_input ? m_state->m_input->size() : 0;

  if (!m_state->m_input || !m_state->m_decoder.decode(length)) {

    if (m_state->m_decoder.m_stream)

      m_state->m_decoder.m_stream->resize((unsigned long)(prevSize));

    return false;

  }

  m_state->m_input->recomputeStreamSize();

  return true;

}

bool CanvasParser::isWindowsFile() const

{

  return m_state->m_isWindowsFile;

}

////////////////////////////////////////////////////////////

// the parser

////////////////////////////////////////////////////////////

void CanvasParser::parse(librevenge::RVNGDrawingInterface *docInterface)

{

  if (!getInput().get() || !checkHeader(nullptr))  throw(libmwaw::ParseException());

  bool ok = false;

  try {

    checkHeader(nullptr);

    ascii().setStream(getInput());

    ascii().open(asciiName());

    if (!readFileHeader())

      throw libmwaw::ParseException();

    bool const isWindows=isWindowsFile();

    m_state->m_decoder.m_isWindows=isWindows;

    m_state->m_decoder.m_version=version();

    if (!m_state->m_decoder.initOutput(getInput(), isWindows ? (unsigned long)(0x920+m_state->m_bitmapSize) : 0x89c) || !m_state->m_decoder.m_stream)

      throw libmwaw::ParseException();

    m_state->m_input.reset(new MWAWInputStream(m_state->m_decoder.m_stream, isWindows));

    // update the style manager and the graph parser and the asciiFile input

    m_styleManager->setInput(m_state->m_input);

    m_graphParser->setInput(m_state->m_input);

    ascii().setStream(m_state->m_input);

    ok = createZones();

    if (ok) {

      createDocument(docInterface);

      for (auto const &layer : m_state->m_layers)

        send(layer);

      m_graphParser->checkUnsent();

    }

  }

  catch (...) {

    MWAW_DEBUG_MSG(("CanvasParser::parse: exception catched when parsing\n"));

    ok = false;

  }

  ascii().reset();

  resetGraphicListener();

  if (!ok) throw(libmwaw::ParseException());

}

////////////////////////////////////////////////////////////

// create the document

////////////////////////////////////////////////////////////

void CanvasParser::createDocument(librevenge::RVNGDrawingInterface *documentInterface)

{

  if (!documentInterface) return;

  if (getGraphicListener()) {

    MWAW_DEBUG_MSG(("CanvasParser::createDocument: listener already exist\n"));

    return;

  }

  // create the page list

  MWAWPageSpan ps(getPageSpan());

  if (m_state->m_numPages!=MWAWVec2i(1,1)) {

    ps.setFormWidth(double(m_state->m_numPages[0])*ps.getFormWidth());

    ps.setFormLength(double(m_state->m_numPages[1])*ps.getFormLength());

  }

  ps.setPageSpan(1);

  std::vector<MWAWPageSpan> pageList(1,ps);

  MWAWGraphicListenerPtr listen(new MWAWGraphicListener(*getParserState(), pageList, documentInterface));

  setGraphicListener(listen);

  if (!m_state->m_metaData.empty())

    listen->setDocumentMetaData(m_state->m_metaData);

  listen->startDocument();

}

////////////////////////////////////////////////////////////

//

// Intermediate level

//

////////////////////////////////////////////////////////////

bool CanvasParser::createZones()

{

  auto input=getInput();

  if (!input) return false;

  MWAWRSRCParserPtr rsrcParser = getRSRCParser();

  if (rsrcParser) {

    auto rsrcInput=rsrcParser->getInput();

    auto &rsrcAscii=rsrcParser->ascii();

    auto const &entryMap = rsrcParser->getEntriesMap();

    for (int w=0; w<5; ++w) {

      static char const* const wh[]= {"HeAd" /*11164*/, "Jinf" /* 10568 */, "WIND" /* 10568 */, "LPol" /* 2,4,... */, "USER" /*0*/};

      auto it = entryMap.lower_bound(wh[w]);

      while (it != entryMap.end() && it->first==wh[w]) {

        auto const &entry=it++->second;

        if (!entry.valid()) continue;

        switch (w) {

        case 0:

          readRSRCFileHeader(rsrcInput, entry, rsrcAscii);

          break;

        case 1:

          readPrintInfo(rsrcInput, entry, rsrcAscii);

          break;

        case 2:

          readWindows(rsrcInput, entry, rsrcAscii);

          break;

        case 3:

          readLPOL(rsrcInput, entry, rsrcAscii);

          break;

        case 4:

        default:

          readUsers(rsrcInput, entry, rsrcAscii);

          break;

        }

      }

    }

  }

  bool const isWindows=m_state->m_isWindowsFile;

  input->seek(0x3c, librevenge::RVNG_SEEK_SET);

  if (isWindows) {

    if (!m_graphParser->readFileBitmap(m_state->m_bitmapSize) || !input->checkPosition(input->tell()+132))

      return false;

    long pos=input->tell();

    libmwaw::DebugStream f;

    f << "Entries(Brush):lengths=[";

    for (int i=0; i<32; ++i) {

      auto length=input->readULong(4);

      m_state->m_brushLengths.push_back(length);

      f << length << ",";

    }

    f << "],";

    f << "f0=" << input->readULong(4) << ","; // small number

    ascii().addPos(pos);

    ascii().addNote(f.str().c_str());

  }

  if (!readUnknownZoneHeader() || !m_styleManager->readPenSize() || !readDocumentHeader() || !readMacroNames() ||

      !readUnknownZone0() || !m_styleManager->readArrows() || !readFormats() || !readGrids() || !readUnknownZone1())

    return false;

  if (!m_graphParser->readShapes(m_state->m_numShapes, m_state->m_lengths[0], m_state->m_lengths[1]))

    return false;

  if (!readLayers() || !readViews() || !m_styleManager->readPatterns(m_state->m_numPatterns))

    return false;

  if (!m_styleManager->readColors(m_state->m_numColors))

    return true;

  if (!readUnknownZone2() || !readBrushes() || !readUnknownZone3())

    return true;

  if (!readSprays() || !readUnknownZone4())

    return true;

  // end of v2

  if (m_state->m_decoder.isEnd())

    return true;

  if (!m_styleManager->readDashes(6) || !readEndV3())

    return true;

  if (isWindows && !readRSRCWindowsFile())

    return true;

  if (m_state->m_decoder.isEnd())

    return true;

  decode(-1);

  MWAW_DEBUG_MSG(("CanvasParser::createZones: unexpected last zone size\n"));

  ascii().addPos(input->tell());

  ascii().addNote("Entries(Last):###");

  return true;

}

bool CanvasParser::readLayers()

{

  if (long(m_state->m_lengths[2])<0 || !decode(long(m_state->m_lengths[2]))) {

    MWAW_DEBUG_MSG(("CanvasParser::readLayers: can not decode the input\n"));

    return false;

  }

  MWAWInputStreamPtr input = getInput();

  long pos=input->tell();

  long endPos=pos+long(m_state->m_lengths[2]);

  if (!input->checkPosition(endPos) || m_state->m_numLayers < 0 ||

      long(m_state->m_lengths[2])/42 < m_state->m_numLayers) {

    MWAW_DEBUG_MSG(("CanvasParser::readLayers: zone seems too short\n"));

    return false;

  }

  libmwaw::DebugStream f;

  f << "Entries(Layer):";

  ascii().addPos(pos);

  ascii().addNote(f.str().c_str());

  std::vector<unsigned long> dataSize;

  m_state->m_layers.resize(size_t(m_state->m_numLayers));

  for (size_t i=0; i<size_t(m_state->m_numLayers); ++i) {

    pos=input->tell();

    f.str("");

    f << "Layer-" << i << ":";

    CanvasParserInternal::Layer &layer=m_state->m_layers[i];

    dataSize.push_back(input->readULong(4));

    f << "dSz=" << dataSize.back() << ",";

    layer.m_numShapes=int(input->readULong(2));

    f << "n[shapes]=" << layer.m_numShapes << ",";

    ascii().addDelimiter(input->tell(),'|');

    input->seek(pos+22, librevenge::RVNG_SEEK_SET);

    ascii().addDelimiter(input->tell(),'|');

    if (readString(layer.m_name, 20))

      f << layer.m_name.cstr() << ",";

    else {

      f << "###name,";

      MWAW_DEBUG_MSG(("CanvasParser::readLayers: bad name\n"));

    }

    input->seek(pos+42, librevenge::RVNG_SEEK_SET);

    ascii().addPos(pos);

    ascii().addNote(f.str().c_str());

  }

  if (input->tell()!=endPos) {

    ascii().addPos(input->tell());

    ascii().addNote("Layer-End:");

    input->seek(endPos, librevenge::RVNG_SEEK_SET);

  }

  for (size_t i=0; i<size_t(m_state->m_numLayers); ++i) {

    if (!dataSize[i]) continue;

    if (long(dataSize[i])<0 || !decode(long(dataSize[i]))) {

      MWAW_DEBUG_MSG(("CanvasParser::readLayers: can not decode the data %d input\n", int(i)));

      return false;

    }

    pos=input->tell();

    f.str("");

    f << "Layer-data" << i << ":";

    auto &layer=m_state->m_layers[i];

    if (!input->checkPosition(pos+long(dataSize[size_t(i)]))) {

      MWAW_DEBUG_MSG(("CanvasParser::readLayers: can not find data %d\n", int(i)));

      f << "###";

      ascii().addPos(pos);

      ascii().addNote(f.str().c_str());

      return false;

    }

    if (long(dataSize[size_t(i)])<2*layer.m_numShapes) {

      MWAW_DEBUG_MSG(("CanvasParser::readLayers: the size seems too short\n"));

      f << "###";

    }

    else {

      if (layer.m_numShapes)

        f << "f0=" << std::hex << input->readULong(2) << std::dec << ",";

      f << "ids=[";

      for (int j=1; j<layer.m_numShapes; ++j) {

        layer.m_shapesId.push_back(int(input->readULong(2)));

        f << layer.m_shapesId.back() << ",";

      }

      f << "],";

      if (long(dataSize[size_t(i)])!=2*layer.m_numShapes)

        ascii().addDelimiter(input->tell(),'|');

    }

    input->seek(pos+long(dataSize[size_t(i)]), librevenge::RVNG_SEEK_SET);

    ascii().addPos(pos);

    ascii().addNote(f.str().c_str());

  }

  return true;

}

////////////////////////////////////////////////////////////

// read the header

////////////////////////////////////////////////////////////

bool CanvasParser::checkHeader(MWAWHeader *header, bool strict)

{

  MWAWInputStreamPtr input = getInput();

  if (!input || !input->hasDataFork() || !input->checkPosition(0x89e))

    return false;

  input->setReadInverted(false);

  input->seek(0x36, librevenge::RVNG_SEEK_SET);

  int val=int(input->readULong(2));

  int vers=0;

  switch (val) {

  case 1:

    vers=2;

    break;

  case 2:

    vers=3;

    break;

  case 0x100:

    input->setReadInverted(true);

    m_state->m_isWindowsFile=true;

    vers=3;

    break;

  default:

    MWAW_DEBUG_MSG(("CanvasParser::checkHeader: unknown version=%d\n", val));

    return false;

  }

  input->seek(0, librevenge::RVNG_SEEK_SET);

  unsigned long lengths[3];

  for (auto &l : lengths) {

    // check that no shape/shape data/layer lengths is empty

    l=input->readULong(4);

    if (l==0)

      return false;

  }

  if (strict) {

    // try to decode the shape and the shape data zone

    CanvasParserInternal::Decoder decoder;

    decoder.m_isWindows=m_state->m_isWindowsFile;

    decoder.m_version=vers;

    input->seek(0x38, librevenge::RVNG_SEEK_SET);

    unsigned long bitmapSize=m_state->m_isWindowsFile ? input->readULong(4) : 0;

    if (long(bitmapSize)<0 || (m_state->m_isWindowsFile && !input->checkPosition(long(0x920+bitmapSize))) ||

        !decoder.initOutput(input, m_state->m_isWindowsFile ? 0x920+bitmapSize : 0x89c) ||

        !decoder.decode(long(lengths[0])) || !decoder.decode(long(lengths[1])))

      return false;

  }

  setVersion(vers);

  if (header)

    header->reset(MWAWDocument::MWAW_T_CANVAS, vers, MWAWDocument::MWAW_K_DRAW);

  return true;

}

bool CanvasParser::readFileHeader()

{

  auto input=getInput();

  long const endPos=0x3c;

  if (!input || !input->checkPosition(endPos)) {

    MWAW_DEBUG_MSG(("CanvasParser::readFileHeader: file is too short\n"));

    return false;

  }

  m_state->m_lengths.clear();

  libmwaw::DebugStream f;

  f << "FileHeader:";

  input->seek(0, librevenge::RVNG_SEEK_SET);

  f << "length=[";

  for (int i=0; i<13; ++i) {

    auto length=input->readULong(4);

    if (i>=4 && i<12)

      m_state->m_brushLengths.push_back(length);

    else

      m_state->m_lengths.push_back(length);

    f << length << ",";

  }

  f << "],";

  ascii().addPos(0);

  ascii().addNote(f.str().c_str());

  long pos=input->tell();

  f.str("");

  f << "FileHeader-end:";

  int val;

  val=int(input->readLong(1));

  if (val==1)

    f << "little[endian],";

  else if (val)

    f << "##endian=" << val << ",";

  val=int(input->readULong(1)); // v2: 100, v3: 104

  switch (val) {

  case 100:

    f << "v2.0,";

    break;

  case 102:

    f << "v2.1,";

    break;

  case 104:

    f << "v3.0,";

    break;

  case 105:

    f << "v3.5,";

    break;

  case 107: // or windows 3.5

    f << "v3.5.2,";

    break;

  default:

    f << "version=" << val << ",";

    break;

  }

  val=int(input->readULong(2));

  if (val!=1) f << "vers=" << val+1 << ",";

  if (isWindowsFile()) {

    m_state->m_bitmapSize=long(input->readULong(4));

    f << "bitmap[size]=" << m_state->m_bitmapSize << ",";

  }

  if (input->tell()!=endPos)

    ascii().addDelimiter(input->tell(),'|');

  ascii().addPos(pos);

  ascii().addNote(f.str().c_str());

  input->seek(endPos, librevenge::RVNG_SEEK_SET);

  return true;

}

bool CanvasParser::readDocumentHeader()

{

  auto input=getInput();

  long pos=input ? input->tell() : 0;

  if (!input || !input->checkPosition(pos+230)) {

    MWAW_DEBUG_MSG(("CanvasParser::readDocumentHeader: file is too short\n"));

    return false;

  }

  libmwaw::DebugStream f;

  f << "Entries(Document):";

  input->seek(pos+46, librevenge::RVNG_SEEK_SET);

  ascii().addDelimiter(input->tell(),'|');

  int dim[2];