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 <cmath>
#include <map>
#include <ostream>
#include <string>
#include <math.h>
#include <vector>

#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif

#include <librevenge-stream/librevenge-stream.h>
#include <librevenge/librevenge.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__ */

// define gmtime_r and localtime_r on Windows, so that can use
// thread-safe functions on other environments
#ifdef _WIN32
#  define gmtime_r(tp,tmp) (gmtime(tp)?(*(tmp)=*gmtime(tp),(tmp)):0)
#  define localtime_r(tp,tmp) (localtime(tp)?(*(tmp)=*localtime(tp),(tmp)):0)
#endif

/* ---------- 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 *) {}
};

#if defined(__clang__) || defined(__GNUC__)
#  define LIBMWAW_ATTRIBUTE_PRINTF(fmt, arg) __attribute__((__format__(__printf__, fmt, arg)))
#else
#  define LIBMWAW_ATTRIBUTE_PRINTF(fmt, arg)
#endif

/* ---------- debug  --------------- */
#ifdef DEBUG
namespace libmwaw
{
void printDebugMsg(const char *format, ...) LIBMWAW_ATTRIBUTE_PRINTF(1,2);
}
#define MWAW_DEBUG_MSG(M) libmwaw::printDebugMsg 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(librevenge::RVNGInputStream *input);
void appendUnicode(uint32_t val, librevenge::RVNGString &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_CHART, DOC_CHART_ZONE, DOC_COMMENT_ANNOTATION, DOC_GRAPHIC_GROUP, DOC_HEADER_FOOTER, DOC_NOTE, DOC_SHEET, DOC_TABLE, DOC_TEXT_BOX };
}

struct MWAWColor {
  MWAWColor(uint32_t argb=0) : m_value(argb)
  {
  }
  MWAWColor(unsigned char r, unsigned char g,  unsigned char b, unsigned char a=255) :
    m_value(uint32_t((a<<24)+(r<<16)+(g<<8)+b))
  {
  }
  MWAWColor &operator=(uint32_t argb)
  {
    m_value = argb;
    return *this;
  }
  static MWAWColor colorFromCMYK(unsigned char c, unsigned char m,  unsigned char y, unsigned char k)
  {
    double w=1.-double(k)/255.;
    return MWAWColor
           ((unsigned char)(255 * (1-double(c)/255) * w),
            (unsigned char)(255 * (1-double(m)/255) * w),
            (unsigned char)(255 * (1-double(y)/255) * w)
           );
  }
  static MWAWColor colorFromHSL(unsigned char H, unsigned char S,  unsigned char L)
  {
    double c=(1-((L>=128) ? (2*double(L)-255) : (255-2*double(L)))/255)*
             double(S)/255;
    double tmp=std::fmod((double(H)*6/255),2)-1;
    double x=c*(1-(tmp>0 ? tmp : -tmp));
    unsigned char C=(unsigned char)(255*c);
    unsigned char M=(unsigned char)(double(L)-255*c/2);
    unsigned char X=(unsigned char)(255*x);
    if (H<=42) return MWAWColor((unsigned char)(M+C),(unsigned char)(M+X),(unsigned char)M);
    if (H<=85) return MWAWColor((unsigned char)(M+X),(unsigned char)(M+C),(unsigned char)M);
    if (H<=127) return MWAWColor((unsigned char)M,(unsigned char)(M+C),(unsigned char)(M+X));
    if (H<=170) return MWAWColor((unsigned char)M,(unsigned char)(M+X),(unsigned char)(M+C));
    if (H<=212) return MWAWColor((unsigned char)(M+X),(unsigned char)M,(unsigned char)(M+C));
    return MWAWColor((unsigned char)(M+C),(unsigned char)(M),(unsigned char)(M+X));
  }
  static MWAWColor black()
  {
    return MWAWColor(0,0,0);
  }
  static MWAWColor white()
  {
    return MWAWColor(255,255,255);
  }

  static MWAWColor barycenter(float alpha, MWAWColor const &colA,
                              float beta, MWAWColor const &colB);
  uint32_t value() const
  {
    return m_value;
  }
  unsigned char getAlpha() const
  {
    return (unsigned char)((m_value>>24)&0xFF);
  }
  unsigned char getBlue() const
  {
    return (unsigned char)(m_value&0xFF);
  }
  unsigned char getRed() const
  {
    return (unsigned char)((m_value>>16)&0xFF);
  }
  unsigned char getGreen() const
  {
    return (unsigned char)((m_value>>8)&0xFF);
  }
  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()), m_extra("") { }
  bool addTo(librevenge::RVNGPropertyList &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;
  std::string m_extra;
};

struct MWAWField {
  enum Type { None, PageCount, PageNumber, Date, Time, Title, 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 MWAWLink {
  MWAWLink() : m_HRef("")
  {
  }

  bool addTo(librevenge::RVNGPropertyList &propList) const;

  std::string m_HRef;
};

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

// forward declarations of basic classes and smart pointers
class MWAWEntry;
class MWAWFont;
class MWAWGraphicEncoder;
class MWAWGraphicShape;
class MWAWGraphicStyle;
class MWAWHeader;
class MWAWList;
class MWAWPageSpan;
class MWAWParagraph;
class MWAWParser;
class MWAWPosition;
class MWAWSection;

class MWAWFontConverter;
class MWAWGraphicListener;
class MWAWInputStream;
class MWAWListener;
class MWAWListManager;
class MWAWParserState;
class MWAWPresentationListener;
class MWAWRSRCParser;
class MWAWSpreadsheetListener;
class MWAWSubDocument;
class MWAWTextListener;
typedef shared_ptr<MWAWFontConverter> MWAWFontConverterPtr;
typedef shared_ptr<MWAWGraphicListener> MWAWGraphicListenerPtr;
typedef shared_ptr<MWAWInputStream> MWAWInputStreamPtr;
typedef shared_ptr<MWAWListener> MWAWListenerPtr;
typedef shared_ptr<MWAWListManager> MWAWListManagerPtr;
typedef shared_ptr<MWAWParserState> MWAWParserStatePtr;
typedef shared_ptr<MWAWPresentationListener> MWAWPresentationListenerPtr;
typedef shared_ptr<MWAWRSRCParser> MWAWRSRCParserPtr;
typedef shared_ptr<MWAWSpreadsheetListener> MWAWSpreadsheetListenerPtr;
typedef shared_ptr<MWAWSubDocument> MWAWSubDocumentPtr;
typedef shared_ptr<MWAWTextListener> MWAWTextListenerPtr;

template <class T> struct MWAWVariable {
  MWAWVariable() : m_data(), m_set(false) {}
  MWAWVariable(T const &def) : m_data(def), m_set(false) {}
  MWAWVariable(MWAWVariable const &orig) : m_data(orig.m_data), m_set(orig.m_set) {}
  MWAWVariable &operator=(MWAWVariable const &orig)
  {
    if (this != &orig) {
      m_data = orig.m_data;
      m_set = orig.m_set;
    }
    return *this;
  }
  MWAWVariable &operator=(T const &val)
  {
    m_data = val;
    m_set = true;
    return *this;
  }
  void insert(MWAWVariable 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 MWAWVec2
{
public:
  MWAWVec2(T xx=0,T yy=0) : m_x(xx), m_y(yy) { }
  template <class U> MWAWVec2(MWAWVec2<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
  {
    if (c<0 || c>1) throw libmwaw::GenericException();
    return (c==0) ? m_x : m_y;
  }
  T &operator[](int c)
  {
    if (c<0 || c>1) throw libmwaw::GenericException();
    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;
  }

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

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

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

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

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

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

typedef MWAWVec2<bool> MWAWVec2b;
typedef MWAWVec2<int> MWAWVec2i;
typedef MWAWVec2<long> MWAWVec2l;
typedef MWAWVec2<float> MWAWVec2f;

template <class T> class MWAWVec3
{
public:
  MWAWVec3(T xx=0,T yy=0,T zz=0)
  {
    m_val[0] = xx;
    m_val[1] = yy;
    m_val[2] = zz;
  }
  template <class U> MWAWVec3(MWAWVec3<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
  {
    if (c<0 || c>2) throw libmwaw::GenericException();
    return m_val[c];
  }
  T &operator[](int c)
  {
    if (c<0 || c>2) throw libmwaw::GenericException();
    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;
  }

  MWAWVec3<T> &operator+=(MWAWVec3<T> const &p)
  {
    for (int c = 0; c < 3; c++) m_val[c] = T(m_val[c]+p.m_val[c]);
    return *this;
  }
  MWAWVec3<T> &operator-=(MWAWVec3<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>
  MWAWVec3<T> &operator*=(U scale)
  {
    for (int c = 0; c < 3; c++) m_val[c] = T(m_val[c]*scale);
    return *this;
  }

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

  bool operator==(MWAWVec3<T> const &p) const
  {
    return cmp(p) == 0;
  }
  bool operator!=(MWAWVec3<T> const &p) const
  {
    return cmp(p) != 0;
  }
  bool operator<(MWAWVec3<T> const &p) const
  {
    return cmp(p) < 0;
  }
  int cmp(MWAWVec3<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, MWAWVec3<T> const &f)
  {
    o << f.m_val[0] << "x" << f.m_val[1] << "x" << f.m_val[2];
    return o;
  }

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

protected:
  T m_val[3];
};

typedef MWAWVec3<unsigned char> MWAWVec3uc;
typedef MWAWVec3<int> MWAWVec3i;
typedef MWAWVec3<float> MWAWVec3f;

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

  MWAWVec2<T> const &min() const
  {
    return m_pt[0];
  }
  MWAWVec2<T> const &max() const
  {
    return m_pt[1];
  }
  MWAWVec2<T> &min()
  {
    return m_pt[0];
  }
  MWAWVec2<T> &max()
  {
    return m_pt[1];
  }
  MWAWVec2<T> const &operator[](int c) const
  {
    if (c<0 || c>1) throw libmwaw::GenericException();
    return m_pt[c];
  }
  MWAWVec2<T> size() const
  {
    return m_pt[1]-m_pt[0];
  }
  MWAWVec2<T> center() const
  {
    return 0.5*(m_pt[0]+m_pt[1]);
  }

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

  void resizeFromMin(MWAWVec2<T> const &sz)
  {
    m_pt[1] = m_pt[0]+sz;
  }
  void resizeFromMax(MWAWVec2<T> const &sz)
  {
    m_pt[0] = m_pt[1]-sz;
  }
  void resizeFromCenter(MWAWVec2<T> const &sz)
  {
    MWAWVec2<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] -= MWAWVec2<T>(val/2,val/2);
    m_pt[1] += MWAWVec2<T>(val-(val/2),val-(val/2));
  }

  MWAWBox2<T> getUnion(MWAWBox2<T> const &box) const
  {
    MWAWBox2<T> res;
    res.m_pt[0]=MWAWVec2<T>(m_pt[0][0]<box.m_pt[0][0]?m_pt[0][0] : box.m_pt[0][0],
                            m_pt[0][1]<box.m_pt[0][1]?m_pt[0][1] : box.m_pt[0][1]);
    res.m_pt[1]=MWAWVec2<T>(m_pt[1][0]>box.m_pt[1][0]?m_pt[1][0] : box.m_pt[1][0],
                            m_pt[1][1]>box.m_pt[1][1]?m_pt[1][1] : box.m_pt[1][1]);
    return res;
  }
  MWAWBox2<T> getIntersection(MWAWBox2<T> const &box) const
  {
    MWAWBox2<T> res;
    res.m_pt[0]=MWAWVec2<T>(m_pt[0][0]>box.m_pt[0][0]?m_pt[0][0] : box.m_pt[0][0],
                            m_pt[0][1]>box.m_pt[0][1]?m_pt[0][1] : box.m_pt[0][1]);
    res.m_pt[1]=MWAWVec2<T>(m_pt[1][0]<box.m_pt[1][0]?m_pt[1][0] : box.m_pt[1][0],
                            m_pt[1][1]<box.m_pt[1][1]?m_pt[1][1] : box.m_pt[1][1]);
    return res;
  }
  bool operator==(MWAWBox2<T> const &p) const
  {
    return cmp(p) == 0;
  }
  bool operator!=(MWAWBox2<T> const &p) const
  {
    return cmp(p) != 0;
  }
  bool operator<(MWAWBox2<T> const &p) const
  {
    return cmp(p) < 0;
  }

  int cmp(MWAWBox2<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, MWAWBox2<T> const &f)
  {
    o << "(" << f.m_pt[0] << "<->" << f.m_pt[1] << ")";
    return o;
  }

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

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

typedef MWAWBox2<int> MWAWBox2i;
typedef MWAWBox2<float> MWAWBox2f;
typedef MWAWBox2<long> MWAWBox2l;

// some geometrical function
namespace libmwaw
{
MWAWBox2f rotateBoxFromCenter(MWAWBox2f const &box, float angle);
}
#endif /* LIBMWAW_INTERNAL_H */
// vim: set filetype=cpp tabstop=2 shiftwidth=2 cindent autoindent smartindent noexpandtab: