libmwaw_internal.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 LIBMWAW_INTERNAL_H
#define LIBMWAW_INTERNAL_H
#include <assert.h>
#ifdef DEBUG
#include <stdio.h>
#endif

#include <map>
#include <ostream>
#include <string>
#include <math.h>
#include <vector>

#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif

#include <libwpd-stream/libwpd-stream.h>
#include <libwpd/libwpd.h>

#if defined(_MSC_VER) || defined(__DJGPP__)

typedef signed char int8_t;
typedef unsigned char uint8_t;
typedef signed short int16_t;
typedef unsigned short uint16_t;
typedef signed int int32_t;
typedef unsigned int uint32_t;
typedef unsigned __int64 uint64_t;
typedef __int64 int64_t;

#else /* !_MSC_VER && !__DJGPP__*/

#ifdef HAVE_CONFIG_H

#include <config.h>

#ifdef HAVE_STDINT_H
#include <stdint.h>
#endif

#ifdef HAVE_INTTYPES_H
#include <inttypes.h>
#endif

#else

// assume that the headers are there inside LibreOffice build when no HAVE_CONFIG_H is defined
#include <stdint.h>
#include <inttypes.h>

#endif

#endif /* _MSC_VER || __DJGPP__ */

/* ---------- memory  --------------- */
#if defined(SHAREDPTR_TR1)
#include <tr1/memory>
using std::tr1::shared_ptr;
#elif defined(SHAREDPTR_STD)
#include <memory>
using std::shared_ptr;
#else
#include <boost/shared_ptr.hpp>
using boost::shared_ptr;
#endif

template <class T>
struct MWAW_shared_ptr_noop_deleter {
  void operator() (T *) {}
};

/* ---------- debug  --------------- */
#ifdef DEBUG
#define MWAW_DEBUG_MSG(M) printf M
#else
#define MWAW_DEBUG_MSG(M)
#endif

namespace libmwaw
{
// Various exceptions:
class VersionException
{
};

class FileException
{
};

class ParseException
{
};

class GenericException
{
};

class WrongPasswordException
{
};
}

/* ---------- input ----------------- */
namespace libmwaw
{
uint8_t readU8(WPXInputStream *input);
void appendUnicode(uint32_t val, WPXString &buffer);
}

/* ---------- small enum/class ------------- */
namespace libmwaw
{
enum Position { Left = 0, Right = 1, Top = 2, Bottom = 3, HMiddle = 4, VMiddle = 5 };
enum { LeftBit = 0x01,  RightBit = 0x02, TopBit=0x4, BottomBit = 0x08, HMiddleBit = 0x10, VMiddleBit = 0x20 };

enum NumberingType { NONE, BULLET, ARABIC, LOWERCASE, UPPERCASE, LOWERCASE_ROMAN, UPPERCASE_ROMAN };
std::string numberingTypeToString(NumberingType type);
std::string numberingValueToString(NumberingType type, int value);
enum SubDocumentType { DOC_NONE, DOC_HEADER_FOOTER, DOC_NOTE, DOC_TABLE, DOC_TEXT_BOX, DOC_COMMENT_ANNOTATION };
}

struct MWAWColor {
  MWAWColor(uint32_t argb=0) : m_value(argb) {
  }
  MWAWColor(unsigned char r, unsigned char g,  unsigned char b, unsigned char a=0) :
    m_value(uint32_t((a<<24)+(r<<16)+(g<<8)+b)) {
  }
  MWAWColor &operator=(uint32_t argb) {
    m_value = argb;
    return *this;
  }
  static MWAWColor black() {
    return MWAWColor(0);
  }
  static MWAWColor white() {
    return MWAWColor(0xFFFFFF);
  }

  static MWAWColor barycenter(float alpha, MWAWColor const &colA,
                              float beta, MWAWColor const &colB);
  uint32_t value() const {
    return m_value;
  }
  bool isBlack() const {
    return (m_value&0xFFFFFF)==0;
  }
  bool isWhite() const {
    return (m_value&0xFFFFFF)==0xFFFFFF;
  }
  bool operator==(MWAWColor const &c) const {
    return (c.m_value&0xFFFFFF)==(m_value&0xFFFFFF);
  }
  bool operator!=(MWAWColor const &c) const {
    return !operator==(c);
  }
  bool operator<(MWAWColor const &c) const {
    return (c.m_value&0xFFFFFF)<(m_value&0xFFFFFF);
  }
  bool operator<=(MWAWColor const &c) const {
    return (c.m_value&0xFFFFFF)<=(m_value&0xFFFFFF);
  }
  bool operator>(MWAWColor const &c) const {
    return !operator<=(c);
  }
  bool operator>=(MWAWColor const &c) const {
    return !operator<(c);
  }
  friend std::ostream &operator<< (std::ostream &o, MWAWColor const &c);
  std::string str() const;
protected:
  uint32_t m_value;
};

struct MWAWBorder {
  enum Style { None, Simple, Dot, LargeDot, Dash };
  enum Type { Single, Double, Triple };

  MWAWBorder() : m_style(Simple), m_type(Single), m_width(1), m_widthsList(), m_color(MWAWColor::black()) { }
  bool addTo(WPXPropertyList &propList, std::string which="") const;
  bool isEmpty() const {
    return m_style==None || m_width <= 0;
  }
  bool operator==(MWAWBorder const &orig) const {
    return !operator!=(orig);
  }
  bool operator!=(MWAWBorder const &orig) const {
    return m_style != orig.m_style || m_type != orig.m_type ||
           m_width < orig.m_width || m_width > orig.m_width || m_color != orig.m_color;
  }
  int compare(MWAWBorder const &orig) const;

  friend std::ostream &operator<< (std::ostream &o, MWAWBorder const &border);
  friend std::ostream &operator<< (std::ostream &o, MWAWBorder::Style const &style);
  Style m_style;
  Type m_type;
  double m_width;
  std::vector<double> m_widthsList;
  MWAWColor m_color;
};

struct MWAWField {
  enum Type { None, PageCount, PageNumber, Date, Time, Title, Link, Database };

  MWAWField(Type type) : m_type(type), m_DTFormat(""), m_numberingType(libmwaw::ARABIC), m_data("") {
  }
  Type m_type;
  std::string m_DTFormat;
  libmwaw::NumberingType m_numberingType;
  std::string m_data;
};

struct MWAWNote {
  enum Type { FootNote, EndNote };
  MWAWNote(Type type) : m_type(type), m_label(""), m_number(-1) {
  }
  Type m_type;
  WPXString m_label;
  int m_number;
};

template <class T> struct Variable {
  Variable() : m_data(), m_set(false) {}
  Variable(T def) : m_data(def), m_set(false) {}
  Variable(Variable const &orig) : m_data(orig.m_data), m_set(orig.m_set) {}
  Variable &operator=(Variable const &orig) {
    if (this != &orig) {
      m_data = orig.m_data;
      m_set = orig.m_set;
    }
    return *this;
  }
  Variable &operator=(T val) {
    m_data = val;
    m_set = true;
    return *this;
  }
  void insert(Variable const &orig) {
    if (orig.m_set) {
      m_data = orig.m_data;
      m_set = orig.m_set;
    }
  }
  T const *operator->() const {
    return &m_data;
  }
  T *operator->() {
    m_set = true;
    return &m_data;
  }
  T const &operator*() const {
    return m_data;
  }
  T &operator*() {
    m_set = true;
    return m_data;
  }
  T const &get() const {
    return m_data;
  }
  bool isSet() const {
    return m_set;
  }
  void setSet(bool newVal) {
    m_set=newVal;
  }
protected:
  T m_data;
  bool m_set;
};

/* ---------- vec2/box2f ------------- */
template <class T> class Vec2
{
public:
  Vec2(T xx=0,T yy=0) : m_x(xx), m_y(yy) { }
  template <class U> Vec2(Vec2<U> const &p) : m_x(T(p.x())), m_y(T(p.y())) {}

  T x() const {
    return m_x;
  }
  T y() const {
    return m_y;
  }
  T operator[](int c) const {
    assert(c >= 0 && c <= 1);
    return (c==0) ? m_x : m_y;
  }
  T &operator[](int c) {
    assert(c >= 0 && c <= 1);
    return (c==0) ? m_x : m_y;
  }

  void set(T xx, T yy) {
    m_x = xx;
    m_y = yy;
  }
  void setX(T xx) {
    m_x = xx;
  }
  void setY(T yy) {
    m_y = yy;
  }

  void add(T dx, T dy) {
    m_x += dx;
    m_y += dy;
  }

  Vec2<T> &operator+=(Vec2<T> const &p) {
    m_x += p.m_x;
    m_y += p.m_y;
    return *this;
  }
  Vec2<T> &operator-=(Vec2<T> const &p) {
    m_x -= p.m_x;
    m_y -= p.m_y;
    return *this;
  }
  template <class U>
  Vec2<T> &operator*=(U scale) {
    m_x = T(m_x*scale);
    m_y = T(m_y*scale);
    return *this;
  }

  friend Vec2<T> operator+(Vec2<T> const &p1, Vec2<T> const &p2) {
    Vec2<T> p(p1);
    return p+=p2;
  }
  friend Vec2<T> operator-(Vec2<T> const &p1, Vec2<T> const &p2) {
    Vec2<T> p(p1);
    return p-=p2;
  }
  template <class U>
  friend Vec2<T> operator*(U scale, Vec2<T> const &p1) {
    Vec2<T> p(p1);
    return p *= scale;
  }

  bool operator==(Vec2<T> const &p) const {
    return cmpY(p) == 0;
  }
  bool operator!=(Vec2<T> const &p) const {
    return cmpY(p) != 0;
  }
  bool operator<(Vec2<T> const &p) const {
    return cmpY(p) < 0;
  }
  int cmp(Vec2<T> const &p) const {
    T diff  = m_x-p.m_x;
    if (diff < 0) return -1;
    if (diff > 0) return 1;
    diff = m_y-p.m_y;
    if (diff < 0) return -1;
    if (diff > 0) return 1;
    return 0;
  }
  int cmpY(Vec2<T> const &p) const {
    T diff  = m_y-p.m_y;
    if (diff < 0) return -1;
    if (diff > 0) return 1;
    diff = m_x-p.m_x;
    if (diff < 0) return -1;
    if (diff > 0) return 1;
    return 0;
  }

  friend std::ostream &operator<< (std::ostream &o, Vec2<T> const &f) {
    o << f.m_x << "x" << f.m_y;
    return o;
  }

  struct PosSizeLtX {
    bool operator()(Vec2<T> const &s1, Vec2<T> const &s2) const {
      return s1.cmp(s2) < 0;
    }
  };
  typedef std::map<Vec2<T>, T,struct PosSizeLtX> MapX;

  struct PosSizeLtY {
    bool operator()(Vec2<T> const &s1, Vec2<T> const &s2) const {
      return s1.cmpY(s2) < 0;
    }
  };
  typedef std::map<Vec2<T>, T,struct PosSizeLtY> MapY;
protected:
  T m_x, m_y;
};

typedef Vec2<bool> Vec2b;
typedef Vec2<int> Vec2i;
typedef Vec2<long> Vec2l;
typedef Vec2<float> Vec2f;

template <class T> class Vec3
{
public:
  Vec3(T xx=0,T yy=0,T zz=0) {
    m_val[0] = xx;
    m_val[1] = yy;
    m_val[2] = zz;
  }
  template <class U> Vec3(Vec3<U> const &p) {
    for (int c = 0; c < 3; c++) m_val[c] = T(p[c]);
  }

  T x() const {
    return m_val[0];
  }
  T y() const {
    return m_val[1];
  }
  T z() const {
    return m_val[2];
  }
  T operator[](int c) const {
    assert(c >= 0 && c <= 2);
    return m_val[c];
  }
  T &operator[](int c) {
    assert(c >= 0 && c <= 2);
    return m_val[c];
  }

  void set(T xx, T yy, T zz) {
    m_val[0] = xx;
    m_val[1] = yy;
    m_val[2] = zz;
  }
  void setX(T xx) {
    m_val[0] = xx;
  }
  void setY(T yy) {
    m_val[1] = yy;
  }
  void setZ(T zz) {
    m_val[2] = zz;
  }

  void add(T dx, T dy, T dz) {
    m_val[0] += dx;
    m_val[1] += dy;
    m_val[2] += dz;
  }

  Vec3<T> &operator+=(Vec3<T> const &p) {
    for (int c = 0; c < 3; c++) m_val[c] = T(m_val[c]+p.m_val[c]);
    return *this;
  }
  Vec3<T> &operator-=(Vec3<T> const &p) {
    for (int c = 0; c < 3; c++) m_val[c] = T(m_val[c]-p.m_val[c]);
    return *this;
  }
  template <class U>
  Vec3<T> &operator*=(U scale) {
    for (int c = 0; c < 3; c++) m_val[c] = T(m_val[c]*scale);
    return *this;
  }

  friend Vec3<T> operator+(Vec3<T> const &p1, Vec3<T> const &p2) {
    Vec3<T> p(p1);
    return p+=p2;
  }
  friend Vec3<T> operator-(Vec3<T> const &p1, Vec3<T> const &p2) {
    Vec3<T> p(p1);
    return p-=p2;
  }
  template <class U>
  friend Vec3<T> operator*(U scale, Vec3<T> const &p1) {
    Vec3<T> p(p1);
    return p *= scale;
  }

  bool operator==(Vec3<T> const &p) const {
    return cmp(p) == 0;
  }
  bool operator!=(Vec3<T> const &p) const {
    return cmp(p) != 0;
  }
  bool operator<(Vec3<T> const &p) const {
    return cmp(p) < 0;
  }
  int cmp(Vec3<T> const &p) const {
    for (int c = 0; c < 3; c++) {
      T diff  = m_val[c]-p.m_val[c];
      if (diff) return (diff < 0) ? -1 : 1;
    }
    return 0;
  }

  friend std::ostream &operator<< (std::ostream &o, Vec3<T> const &f) {
    o << f.m_val[0] << "x" << f.m_val[1] << "x" << f.m_val[2];
    return o;
  }

  struct PosSizeLt {
    bool operator()(Vec3<T> const &s1, Vec3<T> const &s2) const {
      return s1.cmp(s2) < 0;
    }
  };
  typedef std::map<Vec3<T>, T,struct PosSizeLt> Map;

protected:
  T m_val[3];
};

typedef Vec3<unsigned char> Vec3uc;
typedef Vec3<int> Vec3i;
typedef Vec3<float> Vec3f;

template <class T> class Box2
{
public:
  Box2(Vec2<T> minPt=Vec2<T>(), Vec2<T> maxPt=Vec2<T>()) {
    m_pt[0] = minPt;
    m_pt[1] = maxPt;
  }
  template <class U> Box2(Box2<U> const &p) {
    for (int c=0; c < 2; c++) m_pt[c] = p[c];
  }

  Vec2<T> const &min() const {
    return m_pt[0];
  }
  Vec2<T> const &max() const {
    return m_pt[1];
  }
  Vec2<T> &min() {
    return m_pt[0];
  }
  Vec2<T> &max() {
    return m_pt[1];
  }
  Vec2<T> const &operator[](int c) const {
    assert(c >= 0 && c <= 1);
    return m_pt[c];
  }
  Vec2<T> size() const {
    return m_pt[1]-m_pt[0];
  }
  Vec2<T> center() const {
    return 0.5*(m_pt[0]+m_pt[1]);
  }

  void set(Vec2<T> const &x, Vec2<T> const &y) {
    m_pt[0] = x;
    m_pt[1] = y;
  }
  void setMin(Vec2<T> const &x) {
    m_pt[0] = x;
  }
  void setMax(Vec2<T> const &y) {
    m_pt[1] = y;
  }

  void resizeFromMin(Vec2<T> const &sz) {
    m_pt[1] = m_pt[0]+sz;
  }
  void resizeFromMax(Vec2<T> const &sz) {
    m_pt[0] = m_pt[1]-sz;
  }
  void resizeFromCenter(Vec2<T> const &sz) {
    Vec2<T> centerPt = 0.5*(m_pt[0]+m_pt[1]);
    m_pt[0] = centerPt - 0.5*sz;
    m_pt[1] = centerPt + (sz - 0.5*sz);
  }

  template <class U> void scale(U factor) {
    m_pt[0] *= factor;
    m_pt[1] *= factor;
  }

  void extend(T val) {
    m_pt[0] -= Vec2<T>(val/2,val/2);
    m_pt[1] += Vec2<T>(val-(val/2),val-(val/2));
  }

  bool operator==(Box2<T> const &p) const {
    return cmp(p) == 0;
  }
  bool operator!=(Box2<T> const &p) const {
    return cmp(p) != 0;
  }
  bool operator<(Box2<T> const &p) const {
    return cmp(p) < 0;
  }

  int cmp(Box2<T> const &p) const {
    int diff  = m_pt[0].cmpY(p.m_pt[0]);
    if (diff) return diff;
    diff  = m_pt[1].cmpY(p.m_pt[1]);
    if (diff) return diff;
    return 0;
  }

  friend std::ostream &operator<< (std::ostream &o, Box2<T> const &f) {
    o << "(" << f.m_pt[0] << "<->" << f.m_pt[1] << ")";
    return o;
  }

  struct PosSizeLt {
    bool operator()(Box2<T> const &s1, Box2<T> const &s2) const {
      return s1.cmp(s2) < 0;
    }
  };
  typedef std::map<Box2<T>, T,struct PosSizeLt> Map;

protected:
  Vec2<T> m_pt[2];
};

typedef Box2<int> Box2i;
typedef Box2<float> Box2f;
typedef Box2<long> Box2l;

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