RagTime5StructManager.hxx

Go to the documentation of this file.

/* -*- 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.
*/

#ifndef RAG_TIME_5_STRUCT_MANAGER
#  define RAG_TIME_5_STRUCT_MANAGER

#include <ostream>
#include <sstream>
#include <string>
#include <vector>

#include "libmwaw_internal.hxx"
#include "MWAWDebug.hxx"
#include "MWAWEntry.hxx"
#include "MWAWGraphicStyle.hxx"

class RagTime5Zone
{
public:
  enum FileType { F_Main, F_Data, F_Empty, F_Unknown };
  RagTime5Zone(MWAWInputStreamPtr input, libmwaw::DebugFile &asc):
    m_fileType(F_Unknown), m_subType(0), m_defPosition(0), m_entry(), m_name(""), m_hiLoEndian(true),
    m_entriesList(), m_extra(""), m_isParsed(false),
    m_input(input), m_defaultInput(true), m_asciiName(""), m_asciiFile(&asc), m_localAsciiFile()
  {
    for (int i=0; i<3; ++i) m_ids[i]=m_idsFlag[i]=0;
    for (int i=0; i<2; ++i) m_kinds[i]="";
    for (int i=0; i<2; ++i) m_variableD[i]=0;
  }
  virtual ~RagTime5Zone() {}
  std::string getZoneName() const;
  bool isHeaderZone() const
  {
    return (m_fileType==F_Data && m_ids[0]==0) ||
           (m_fileType==F_Main && (m_ids[0]==1 || m_ids[0]==4 || m_ids[0]==5));
  }
  std::string getKindLastPart(bool main=true) const
  {
    std::string res(m_kinds[main ? 0 : 1]);
    std::string::size_type pos = res.find_last_of(':');
    if (pos == std::string::npos) return res;
    return res.substr(pos+1);
  }

  friend std::ostream &operator<<(std::ostream &o, RagTime5Zone const &z);
  MWAWInputStreamPtr getInput()
  {
    return m_input;
  }
  void setInput(MWAWInputStreamPtr input)
  {
    m_input = input;
    m_defaultInput = false;
  }
  bool isMainInput() const
  {
    return m_defaultInput;
  }
  libmwaw::DebugFile &ascii()
  {
    if (!m_defaultInput && !m_localAsciiFile)
      createAsciiFile();
    return *m_asciiFile;
  }
  void setAsciiFileName(std::string const &name)
  {
    m_asciiName = name;
  }
  void createAsciiFile();

  FileType m_fileType;
  int m_subType;
  long m_defPosition;
  std::string m_kinds[2];
  MWAWEntry m_entry;
  std::string m_name;
  bool m_hiLoEndian;
  int m_ids[3];
  int m_idsFlag[3];
  std::vector<MWAWEntry> m_entriesList;
  std::string m_extra;
  int m_variableD[2];
  bool m_isParsed;
protected:
  MWAWInputStreamPtr m_input;
  bool m_defaultInput;
  std::string m_asciiName;
  libmwaw::DebugFile *m_asciiFile;
  shared_ptr<libmwaw::DebugFile> m_localAsciiFile;
private:
  RagTime5Zone(RagTime5Zone const &orig);
  RagTime5Zone &operator=(RagTime5Zone const &orig);
};

class RagTime5StructManager
{
public:
  struct Field;
  RagTime5StructManager();
  ~RagTime5StructManager();

  bool readTypeDefinitions(RagTime5Zone &zone);
  bool readField(MWAWInputStreamPtr input, long endPos, libmwaw::DebugFile &ascFile,
                 Field &field, long fSz=0);
  static bool readCompressedLong(MWAWInputStreamPtr &input, long endPos, long &val);
  static bool readUnicodeString(MWAWInputStreamPtr input, long endPos, librevenge::RVNGString &string);
  static bool readDataIdList(MWAWInputStreamPtr input, int n, std::vector<int> &listIds);

  struct TabStop {
    TabStop() : m_position(0), m_type(1), m_leader("")
    {
    }
    friend std::ostream &operator<<(std::ostream &o, TabStop const &tab)
    {
      o << tab.m_position;
      switch (tab.m_type) {
      case 1:
        break;
      case 2:
        o << "R";
        break;
      case 3:
        o << "C";
        break;
      case 4:
        o << "D";
        break;
      case 5: // Kintou Waritsuke: sort of center
        o << "K";
        break;
      default:
        o << ":#type=" << tab.m_type;
        break;
      }
      if (!tab.m_leader.empty())
        o << ":leader=" << tab.m_leader.cstr();
      return o;
    }
    float m_position;
    int m_type;
    librevenge::RVNGString m_leader;
  };
  struct Field {
    enum Type { T_Unknown, T_Bool, T_Double, T_Long, T_2Long, T_FieldList, T_LongList, T_DoubleList, T_TabList,
                T_Code, T_Color, T_CondColor, T_PrintInfo, T_String, T_Unicode, T_ZoneId, T_LongDouble, T_Unstructured
              };

    Field() : m_type(T_Unknown), m_fileType(0), m_name(""), m_doubleValue(0), m_color(), m_string(""),
      m_longList(), m_doubleList(), m_numLongByData(1), m_tabList(), m_fieldList(), m_entry(), m_extra("")
    {
      for (int i=0; i<2; ++i) m_longValue[i]=0;
    }
    ~Field()
    {
    }
    friend std::ostream &operator<<(std::ostream &o, Field const &field);
    Type m_type;
    long m_fileType;
    std::string m_name;
    long m_longValue[2];
    double m_doubleValue;
    MWAWColor m_color;
    librevenge::RVNGString m_string;
    std::vector<long> m_longList;
    std::vector<double> m_doubleList;
    int m_numLongByData;
    std::vector<TabStop> m_tabList;
    std::vector<Field> m_fieldList;
    MWAWEntry m_entry;
    std::string m_extra;
  };
  struct FieldParser {
    FieldParser(std::string const &zoneName) : m_regroupFields(false), m_name(zoneName) {}
    virtual ~FieldParser() {}
    virtual std::string getZoneName() const
    {
      return m_name;
    }
    virtual std::string getZoneName(int n) const
    {
      std::stringstream s;
      s << m_name << "-" << n;
      return s.str();
    }
    virtual bool parseField(Field &field, RagTime5Zone &/*zone*/, int /*n*/, libmwaw::DebugStream &f)
    {
      f << field;
      return true;
    }
    bool m_regroupFields;
  protected:
    std::string m_name;
  private:
    FieldParser(FieldParser const &orig);
    FieldParser &operator=(FieldParser const &orig);
  };
  struct DataParser {
    DataParser(std::string const &zoneName) : m_name(zoneName)  {}
    virtual ~DataParser() {}
    virtual std::string getZoneName() const
    {
      return m_name;
    }
    virtual std::string getZoneName(int n) const
    {
      std::stringstream s;
      s << m_name << "-" << n;
      return s.str();
    }
    virtual bool parseData(MWAWInputStreamPtr &/*input*/, long /*endPos*/, RagTime5Zone &/*zone*/, int /*n*/, libmwaw::DebugStream &/*f*/)
    {
      return true;
    }
  protected:
    std::string m_name;
  private:
    DataParser(DataParser const &orig);
    DataParser &operator=(DataParser const &orig);
  };
  struct GraphicStyle {
    GraphicStyle() : m_parentId(-1), m_width(-1), m_dash(), m_pattern(), m_gradient(0), m_gradientRotation(0), m_gradientCenter(0.5f,0.5f),
      m_position(2), m_cap(1), m_mitter(1), m_limitPercent(1), m_hidden(false), m_extra("")
    {
      m_colors[0]=MWAWColor::black();
      m_colors[1]=MWAWColor::white();
      m_colorsAlpha[0]=m_colorsAlpha[1]=1;
    }
    virtual ~GraphicStyle()
    {
    }
    bool isDefault() const
    {
      return m_parentId<0 && m_width<0 && m_dash.empty() && !m_pattern &&
             m_gradient==0 && m_gradientRotation<=0 && m_gradientRotation>=0 && m_gradientCenter!=MWAWVec2f(0.5f, 0.5f) &&
             m_position==2 && m_cap==1 && m_mitter==1 &&
             m_colors[0].isBlack() && m_colors[1].isWhite() && m_colorsAlpha[0]>=1 && m_colorsAlpha[1]>=1 &&
             m_limitPercent>=1 && m_limitPercent<=1 && !m_hidden && m_extra.empty();
    }
    friend std::ostream &operator<<(std::ostream &o, GraphicStyle const &style);
    bool read(MWAWInputStreamPtr &input, Field const &field);
    int m_parentId;
    float m_width;
    MWAWColor m_colors[2];
    float m_colorsAlpha[2];
    std::vector<long> m_dash;
    shared_ptr<MWAWGraphicStyle::Pattern> m_pattern;
    int m_gradient;
    float m_gradientRotation;
    MWAWVec2f m_gradientCenter;
    int m_position;
    int m_cap;
    int m_mitter;
    float m_limitPercent;
    bool m_hidden;
    std::string m_extra;
  };
  struct TextStyle {
    TextStyle() : m_linkIdList(),
      m_dateStyleId(-1), m_graphStyleId(-1), m_graphLineStyleId(-1), m_keepWithNext(false), m_justify(-1), m_breakMethod(-1), m_tabList(),
      m_fontName(""), m_fontId(-1), m_fontSize(-1), m_scriptPosition(0), m_fontScaling(-1), m_underline(-1), m_caps(-1), m_language(-1),
      m_numColumns(-1), m_columnGap(-1), m_extra("")
    {
      m_parentId[0]=m_parentId[1]=-1;
      m_fontFlags[0]=m_fontFlags[1]=0;
      for (int i=0; i<3; ++i) {
        m_margins[i]=-1;
        m_spacings[i]=-1;
        m_spacingUnits[i]=-1;
        m_letterSpacings[i]=-1;
      }
    }
    virtual ~TextStyle()
    {
    }
    bool isDefault() const
    {
      if (m_parentId[0]>=0 || m_parentId[1]>=0 || !m_linkIdList.empty() ||
          m_dateStyleId>=0 || m_graphStyleId>=0 || m_graphLineStyleId>=0 ||
          m_keepWithNext.isSet() || m_justify>=0 || m_breakMethod>=0 || !m_tabList.empty() ||
          !m_fontName.empty() || m_fontId>=0 || m_fontSize>=0 || m_fontFlags[0] || m_fontFlags[1] || m_scriptPosition.isSet() ||
          m_fontScaling>=0 || m_underline>=0 || m_caps>=0 || m_language>=0 ||
          m_numColumns>=0 || m_columnGap>=0 || !m_extra.empty())
        return false;
      for (int i=0; i<3; ++i) {
        if (m_margins[i]>=0 || m_spacings[i]>=0 || m_spacingUnits[i]>=0 || m_letterSpacings[i]>=0)
          return false;
      }
      return true;
    }
    friend std::ostream &operator<<(std::ostream &o, TextStyle const &style);
    bool read(MWAWInputStreamPtr &input, Field const &field);
    int m_parentId[2];
    std::vector<int> m_linkIdList;
    int m_dateStyleId;
    int m_graphStyleId;
    int m_graphLineStyleId;

    // paragraph

    MWAWVariable<bool> m_keepWithNext;
    int m_justify;
    double m_spacings[3];
    int m_spacingUnits[3];
    int m_breakMethod;
    double m_margins[3];
    std::vector<TabStop> m_tabList;

    // character

    librevenge::RVNGString m_fontName;
    long m_fontId;
    float m_fontSize;
    uint32_t m_fontFlags[2];
    MWAWVariable<float> m_scriptPosition;
    float m_fontScaling;
    int m_underline;
    int m_caps;
    int m_language;
    double m_letterSpacings[3];

    // column

    int m_numColumns;
    double m_columnGap;

    std::string m_extra;
  };

private:
  RagTime5StructManager(RagTime5StructManager const &orig);
  RagTime5StructManager operator=(RagTime5StructManager const &orig);
};

#endif
// vim: set filetype=cpp tabstop=2 shiftwidth=2 cindent autoindent smartindent noexpandtab: