put all symbols into namespace libmspub

Change-Id: I0a918d738288838f059f7606bd00979cbe4cc99a

14 files changed, 386 insertions, 327 deletions

diff --git a/src/lib/ColorReference.cpp b/src/lib/ColorReference.cpp
index b56c617..ff960d5 100644
--- a/src/lib/ColorReference.cpp
+++ b/src/lib/ColorReference.cpp
@@ -9,7 +9,10 @@
 
 #include "ColorReference.h"
 
-libmspub::Color libmspub::ColorReference::getRealColor(unsigned c, const std::vector<Color> &palette) const
+namespace libmspub
+{
+
+Color ColorReference::getRealColor(unsigned c, const std::vector<Color> &palette) const
 {
   unsigned char type = (c >> 24) & 0xFF;
   if (type == 0x08)
@@ -22,7 +25,7 @@ libmspub::Color libmspub::ColorReference::getRealColor(unsigned c, const std::ve
   }
   return Color(c & 0xFF, (c >> 8) & 0xFF, (c >> 16) & 0xFF);
 }
-libmspub::Color libmspub::ColorReference::getFinalColor(const std::vector<Color> &palette) const
+Color ColorReference::getFinalColor(const std::vector<Color> &palette) const
 {
   unsigned char modifiedType = (m_modifiedColor >> 24) & 0xFF;
   if (modifiedType == CHANGE_INTENSITY)
@@ -46,9 +49,7 @@ libmspub::Color libmspub::ColorReference::getFinalColor(const std::vector<Color>
   }
 }
 
-namespace libmspub
-{
-bool operator==(const libmspub::ColorReference &l, const libmspub::ColorReference &r)
+bool operator==(const ColorReference &l, const ColorReference &r)
 {
   return l.m_baseColor == r.m_baseColor && l.m_modifiedColor == r.m_modifiedColor;
 }
diff --git a/src/lib/Dash.cpp b/src/lib/Dash.cpp
index b850d64..0f40b81 100644
--- a/src/lib/Dash.cpp
+++ b/src/lib/Dash.cpp
@@ -10,17 +10,20 @@
 #include "Dash.h"
 #include "libmspub_utils.h"
 
-bool libmspub::operator==(const libmspub::Dot &lhs, const libmspub::Dot &rhs)
+namespace libmspub
+{
+
+bool operator==(const Dot &lhs, const Dot &rhs)
 {
   return lhs.m_length == rhs.m_length && lhs.m_count == rhs.m_count;
 }
 
-bool libmspub::operator!=(const libmspub::Dot &lhs, const libmspub::Dot &rhs)
+bool operator!=(const Dot &lhs, const Dot &rhs)
 {
   return !operator==(lhs, rhs);
 }
 
-bool libmspub::operator==(const libmspub::Dash &lhs, const libmspub::Dash &rhs)
+bool operator==(const Dash &lhs, const Dash &rhs)
 {
   if (!(lhs.m_distance == rhs.m_distance &&
         lhs.m_dotStyle == rhs.m_dotStyle && lhs.m_dots.size() == rhs.m_dots.size()))
@@ -37,8 +40,8 @@ bool libmspub::operator==(const libmspub::Dash &lhs, const libmspub::Dash &rhs)
   return true;
 }
 
-libmspub::Dash libmspub::getDash(MSPUBDashStyle style, unsigned shapeLineWidthEmu,
-                                 DotStyle dotStyle)
+Dash getDash(MSPUBDashStyle style, unsigned shapeLineWidthEmu,
+             DotStyle dotStyle)
 {
   double shapeLineWidth = static_cast<double>(shapeLineWidthEmu) /
                           EMUS_IN_INCH;
@@ -116,4 +119,6 @@ libmspub::Dash libmspub::getDash(MSPUBDashStyle style, unsigned shapeLineWidthEm
   }
 }
 
+}
+
 /* vim:set shiftwidth=2 softtabstop=2 expandtab: */
diff --git a/src/lib/Fill.cpp b/src/lib/Fill.cpp
index 4de6408..bb0a1ca 100644
--- a/src/lib/Fill.cpp
+++ b/src/lib/Fill.cpp
@@ -12,7 +12,8 @@
 #include "libmspub_utils.h"
 #include "MSPUBCollector.h"
 
-using namespace libmspub;
+namespace libmspub
+{
 
 Fill::Fill(const MSPUBCollector *owner) : m_owner(owner)
 {
@@ -170,4 +171,6 @@ void GradientFill::getProperties(librevenge::RVNGPropertyList *out) const
   out->insert("svg:linearGradient", ret);
 }
 
+}
+
 /* vim:set shiftwidth=2 softtabstop=2 expandtab: */
diff --git a/src/lib/MSPUBCollector.cpp b/src/lib/MSPUBCollector.cpp
index 578398d..6a22f17 100644
--- a/src/lib/MSPUBCollector.cpp
+++ b/src/lib/MSPUBCollector.cpp
@@ -18,6 +18,9 @@
 #include "PolygonUtils.h"
 #include "Coordinate.h"
 
+namespace libmspub
+{
+
 namespace
 {
 
@@ -102,72 +105,72 @@ static void separateSpacesAndInsertText(librevenge::RVNGDrawingInterface *iface,
 
 } // anonymous namespace
 
-librevenge::RVNGBinaryData &libmspub::MSPUBCollector::addEOTFont(const librevenge::RVNGString &name)
+librevenge::RVNGBinaryData &MSPUBCollector::addEOTFont(const librevenge::RVNGString &name)
 {
   m_embeddedFonts.push_back(EmbeddedFontInfo(name));
   return m_embeddedFonts.back().m_blob;
 }
 
-void libmspub::MSPUBCollector::setShapePictureRecolor(unsigned seqNum,
-                                                      const ColorReference &recolor)
+void MSPUBCollector::setShapePictureRecolor(unsigned seqNum,
+                                            const ColorReference &recolor)
 {
   m_shapeInfosBySeqNum[seqNum].m_pictureRecolor = recolor;
 }
 
-void libmspub::MSPUBCollector::setShapePictureBrightness(unsigned seqNum,
-                                                         int brightness)
+void MSPUBCollector::setShapePictureBrightness(unsigned seqNum,
+                                               int brightness)
 {
   m_shapeInfosBySeqNum[seqNum].m_pictureBrightness = brightness;
 }
 
-void libmspub::MSPUBCollector::setShapePictureContrast(unsigned seqNum,
-                                                       int contrast)
+void MSPUBCollector::setShapePictureContrast(unsigned seqNum,
+                                             int contrast)
 {
   m_shapeInfosBySeqNum[seqNum].m_pictureContrast = contrast;
 }
 
-void libmspub::MSPUBCollector::setShapeBeginArrow(unsigned seqNum,
-                                                  const Arrow &arrow)
+void MSPUBCollector::setShapeBeginArrow(unsigned seqNum,
+                                        const Arrow &arrow)
 {
   m_shapeInfosBySeqNum[seqNum].m_beginArrow = arrow;
 }
 
-void libmspub::MSPUBCollector::setShapeVerticalTextAlign(unsigned seqNum,
-                                                         VerticalAlign va)
+void MSPUBCollector::setShapeVerticalTextAlign(unsigned seqNum,
+                                               VerticalAlign va)
 {
   m_shapeInfosBySeqNum[seqNum].m_verticalAlign = va;
 }
 
-void libmspub::MSPUBCollector::setShapeEndArrow(unsigned seqNum,
-                                                const Arrow &arrow)
+void MSPUBCollector::setShapeEndArrow(unsigned seqNum,
+                                      const Arrow &arrow)
 {
   m_shapeInfosBySeqNum[seqNum].m_endArrow = arrow;
 }
 
-void libmspub::MSPUBCollector::setShapeTableInfo(unsigned seqNum,
-                                                 const TableInfo &ti)
+void MSPUBCollector::setShapeTableInfo(unsigned seqNum,
+                                       const TableInfo &ti)
 {
   m_shapeInfosBySeqNum[seqNum].m_tableInfo = ti;
 }
 
-void libmspub::MSPUBCollector::setShapeNumColumns(unsigned seqNum,
-                                                  unsigned numColumns)
+void MSPUBCollector::setShapeNumColumns(unsigned seqNum,
+                                        unsigned numColumns)
 {
   m_shapeInfosBySeqNum[seqNum].m_numColumns = numColumns;
 }
 
-void libmspub::MSPUBCollector::setShapeColumnSpacing(unsigned seqNum,
-                                                     unsigned spacing)
+void MSPUBCollector::setShapeColumnSpacing(unsigned seqNum,
+                                           unsigned spacing)
 {
   m_shapeInfosBySeqNum[seqNum].m_columnSpacing = spacing;
 }
 
-void libmspub::MSPUBCollector::setShapeStretchBorderArt(unsigned seqNum)
+void MSPUBCollector::setShapeStretchBorderArt(unsigned seqNum)
 {
   m_shapeInfosBySeqNum[seqNum].m_stretchBorderArt = true;
 }
 
-void libmspub::MSPUBCollector::setRectCoordProps(Coordinate coord, librevenge::RVNGPropertyList *props) const
+void MSPUBCollector::setRectCoordProps(Coordinate coord, librevenge::RVNGPropertyList *props) const
 {
   int xs = coord.m_xs, ys = coord.m_ys, xe = coord.m_xe, ye = coord.m_ye;
   double x_center = m_width / 2;
@@ -178,28 +181,28 @@ void libmspub::MSPUBCollector::setRectCoordProps(Coordinate coord, librevenge::R
   props->insert("svg:height", (double)(ye - ys) / EMUS_IN_INCH);
 }
 
-libmspub::Coordinate getFudgedCoordinates(libmspub::Coordinate coord, const std::vector<libmspub::Line> &lines, bool makeBigger, libmspub::BorderPosition borderPosition)
+Coordinate getFudgedCoordinates(Coordinate coord, const std::vector<Line> &lines, bool makeBigger, BorderPosition borderPosition)
 {
-  libmspub::Coordinate fudged = coord;
+  Coordinate fudged = coord;
   unsigned topFudge = 0;
   unsigned rightFudge = 0;
   unsigned bottomFudge = 0;
   unsigned leftFudge = 0;
   switch (borderPosition)
   {
-  case libmspub::HALF_INSIDE_SHAPE:
+  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 libmspub::OUTSIDE_SHAPE:
+  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 libmspub::INSIDE_SHAPE:
+  case INSIDE_SHAPE:
   default:
     break;
   }
@@ -220,7 +223,7 @@ libmspub::Coordinate getFudgedCoordinates(libmspub::Coordinate coord, const std:
   return fudged;
 }
 
-void libmspub::MSPUBCollector::setNextPage(unsigned pageSeqNum)
+void MSPUBCollector::setNextPage(unsigned pageSeqNum)
 {
   m_pageSeqNumsOrdered.push_back(pageSeqNum);
 }
@@ -229,7 +232,7 @@ void libmspub::MSPUBCollector::setNextPage(unsigned pageSeqNum)
 #define M_PI 3.14159265358979323846
 #endif
 
-libmspub::MSPUBCollector::MSPUBCollector(librevenge::RVNGDrawingInterface *painter) :
+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(),
@@ -251,54 +254,54 @@ libmspub::MSPUBCollector::MSPUBCollector(librevenge::RVNGDrawingInterface *paint
 {
 }
 
-void libmspub::MSPUBCollector::setTextStringOffset(
+void MSPUBCollector::setTextStringOffset(
   unsigned textId, unsigned offset)
 {
   m_stringOffsetsByTextId[textId] = offset;
 }
 
-void libmspub::MSPUBCollector::setNextTableCellTextEnds(
+void MSPUBCollector::setNextTableCellTextEnds(
   const std::vector<unsigned> &ends)
 {
   m_tableCellTextEndsVector.push_back(ends);
 }
 
-void libmspub::MSPUBCollector::useEncodingHeuristic()
+void MSPUBCollector::useEncodingHeuristic()
 {
   m_encodingHeuristic = true;
 }
 
-void libmspub::MSPUBCollector::setShapeShadow(unsigned seqNum, const Shadow &shadow)
+void MSPUBCollector::setShapeShadow(unsigned seqNum, const Shadow &shadow)
 {
   m_shapeInfosBySeqNum[seqNum].m_shadow = shadow;
 }
 
-void libmspub::noop(const CustomShape *)
+void noop(const CustomShape *)
 {
 }
 
-void libmspub::MSPUBCollector::setShapeCoordinatesRotated90(unsigned seqNum)
+void MSPUBCollector::setShapeCoordinatesRotated90(unsigned seqNum)
 {
   m_shapesWithCoordinatesRotated90.insert(seqNum);
 }
 
-void libmspub::MSPUBCollector::setShapeBorderImageId(unsigned seqNum, unsigned id)
+void MSPUBCollector::setShapeBorderImageId(unsigned seqNum, unsigned id)
 {
   m_shapeInfosBySeqNum[seqNum].m_borderImgIndex = id;
 }
 
-void libmspub::MSPUBCollector::setShapeCustomPath(unsigned seqNum,
-                                                  const DynamicCustomShape &shape)
+void MSPUBCollector::setShapeCustomPath(unsigned seqNum,
+                                        const DynamicCustomShape &shape)
 {
   m_shapeInfosBySeqNum[seqNum].m_customShape = shape;
 }
 
-void libmspub::MSPUBCollector::setShapeClipPath(unsigned seqNum, const std::vector<libmspub::Vertex> &clip)
+void MSPUBCollector::setShapeClipPath(unsigned seqNum, const std::vector<Vertex> &clip)
 {
   m_shapeInfosBySeqNum[seqNum].m_clipPath = clip;
 }
 
-void libmspub::MSPUBCollector::beginGroup()
+void MSPUBCollector::beginGroup()
 {
   ShapeGroupElement *tmp = new ShapeGroupElement(m_currentShapeGroup);
   if (!m_currentShapeGroup)
@@ -308,7 +311,7 @@ void libmspub::MSPUBCollector::beginGroup()
   m_currentShapeGroup = tmp;
 }
 
-bool libmspub::MSPUBCollector::endGroup()
+bool MSPUBCollector::endGroup()
 {
   if (!m_currentShapeGroup)
   {
@@ -318,32 +321,32 @@ bool libmspub::MSPUBCollector::endGroup()
   return true;
 }
 
-void libmspub::MSPUBCollector::addShapeLine(unsigned seqNum, Line line)
+void MSPUBCollector::addShapeLine(unsigned seqNum, Line line)
 {
   m_shapeInfosBySeqNum[seqNum].m_lines.push_back(line);
 }
 
-void libmspub::MSPUBCollector::setShapeBorderPosition(unsigned seqNum, BorderPosition pos)
+void MSPUBCollector::setShapeBorderPosition(unsigned seqNum, BorderPosition pos)
 {
   m_shapeInfosBySeqNum[seqNum].m_borderPosition = pos;
 }
 
-bool libmspub::MSPUBCollector::hasPage(unsigned seqNum) const
+bool MSPUBCollector::hasPage(unsigned seqNum) const
 {
   return m_pagesBySeqNum.find(seqNum) != m_pagesBySeqNum.end();
 }
 
-void libmspub::MSPUBCollector::setShapeMargins(unsigned seqNum, unsigned left, unsigned top, unsigned right, unsigned bottom)
+void MSPUBCollector::setShapeMargins(unsigned seqNum, unsigned left, unsigned top, unsigned right, unsigned bottom)
 {
   m_shapeInfosBySeqNum[seqNum].m_margins = Margins(left, top, right, bottom);
 }
 
-void libmspub::MSPUBCollector::setPageBgShape(unsigned pageSeqNum, unsigned seqNum)
+void MSPUBCollector::setPageBgShape(unsigned pageSeqNum, unsigned seqNum)
 {
   m_bgShapeSeqNumsByPageSeqNum[pageSeqNum] = seqNum;
 }
 
-bool libmspub::MSPUBCollector::setCurrentGroupSeqNum(unsigned seqNum)
+bool MSPUBCollector::setCurrentGroupSeqNum(unsigned seqNum)
 {
   if (!m_currentShapeGroup)
   {
@@ -354,7 +357,7 @@ bool libmspub::MSPUBCollector::setCurrentGroupSeqNum(unsigned seqNum)
   return true;
 }
 
-void libmspub::MSPUBCollector::setShapeOrder(unsigned seqNum)
+void MSPUBCollector::setShapeOrder(unsigned seqNum)
 {
   ShapeGroupElement *tmp = new ShapeGroupElement(m_currentShapeGroup, seqNum);
   if (!m_currentShapeGroup)
@@ -363,7 +366,7 @@ void libmspub::MSPUBCollector::setShapeOrder(unsigned seqNum)
   }
 }
 
-void libmspub::MSPUBCollector::addPaletteColor(Color c)
+void MSPUBCollector::addPaletteColor(Color c)
 {
   m_paletteColors.push_back(c);
 }
@@ -377,7 +380,7 @@ void endShapeGroup(librevenge::RVNGDrawingInterface *painter)
   painter->endLayer();
 }
 
-std::vector<int> libmspub::MSPUBCollector::getShapeAdjustValues(const ShapeInfo &info) const
+std::vector<int> MSPUBCollector::getShapeAdjustValues(const ShapeInfo &info) const
 {
   std::vector<int> ret;
   boost::shared_ptr<const CustomShape> ptr_shape = info.getCustomShape();
@@ -402,7 +405,7 @@ std::vector<int> libmspub::MSPUBCollector::getShapeAdjustValues(const ShapeInfo
   return ret;
 }
 
-boost::optional<std::vector<libmspub::TextParagraph> > libmspub::MSPUBCollector::getShapeText(const ShapeInfo &info) const
+boost::optional<std::vector<TextParagraph> > MSPUBCollector::getShapeText(const ShapeInfo &info) const
 {
   if (!!info.m_textId)
   {
@@ -416,7 +419,7 @@ boost::optional<std::vector<libmspub::TextParagraph> > libmspub::MSPUBCollector:
   return boost::optional<std::vector<TextParagraph> >();
 }
 
-void libmspub::MSPUBCollector::setupShapeStructures(ShapeGroupElement &elt)
+void MSPUBCollector::setupShapeStructures(ShapeGroupElement &elt)
 {
   ShapeInfo *ptr_info = getIfExists(m_shapeInfosBySeqNum, elt.getSeqNum());
   if (ptr_info)
@@ -444,7 +447,7 @@ void libmspub::MSPUBCollector::setupShapeStructures(ShapeGroupElement &elt)
 }
 
 
-boost::function<void(void)> libmspub::MSPUBCollector::paintShape(const ShapeInfo &info, const Coordinate &/* relativeTo*/, const VectorTransformation2D &foldedTransform, bool isGroup, const VectorTransformation2D &thisTransform) const
+boost::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)
@@ -563,7 +566,7 @@ boost::function<void(void)> libmspub::MSPUBCollector::paintShape(const ShapeInfo
 
     writeCustomShape(type, graphicsProps, m_painter, x, y, height, width,
                      true, foldedTransform,
-                     std::vector<Line>(), boost::bind(&libmspub::MSPUBCollector::getCalculationValue, this, info, _1, false, adjustValues), m_paletteColors, info.getCustomShape());
+                     std::vector<Line>(), boost::bind(&MSPUBCollector::getCalculationValue, this, info, _1, false, adjustValues), m_paletteColors, info.getCustomShape());
     if (!!info.m_pictureRecolor)
     {
       graphicsProps.remove("draw:color-mode");
@@ -842,7 +845,7 @@ boost::function<void(void)> libmspub::MSPUBCollector::paintShape(const ShapeInfo
       writeCustomShape(type, graphicsProps, m_painter, x, y, height, width,
                        false, foldedTransform, lines,
                        boost::bind(
-                         &libmspub::MSPUBCollector::getCalculationValue, this, info, _1, false, adjustValues
+                         &MSPUBCollector::getCalculationValue, this, info, _1, false, adjustValues
                        ),
                        m_paletteColors, info.getCustomShape());
     }
@@ -920,7 +923,7 @@ boost::function<void(void)> libmspub::MSPUBCollector::paintShape(const ShapeInfo
   return &no_op;
 }
 
-const char *libmspub::MSPUBCollector::getCalculatedEncoding() const
+const char *MSPUBCollector::getCalculatedEncoding() const
 {
   if (!!m_calculatedEncoding)
   {
@@ -982,15 +985,15 @@ csd_fail:
   return "windows-1252"; // Pretty likely to give garbage text, but it's the best we can do.
 }
 
-void libmspub::MSPUBCollector::setShapeLineBackColor(unsigned shapeSeqNum,
-                                                     ColorReference backColor)
+void MSPUBCollector::setShapeLineBackColor(unsigned shapeSeqNum,
+                                           ColorReference backColor)
 {
   m_shapeInfosBySeqNum[shapeSeqNum].m_lineBackColor = backColor;
 }
 
-void libmspub::MSPUBCollector::writeImage(double x, double y,
-                                          double height, double width, ImgType type, const librevenge::RVNGBinaryData &blob,
-                                          boost::optional<Color> oneBitColor) const
+void MSPUBCollector::writeImage(double x, double y,
+                                double height, double width, ImgType type, const librevenge::RVNGBinaryData &blob,
+                                boost::optional<Color> oneBitColor) const
 {
   librevenge::RVNGPropertyList props;
   if (!!oneBitColor)
@@ -1010,7 +1013,7 @@ void libmspub::MSPUBCollector::writeImage(double x, double y,
   m_painter->drawGraphicObject(props);
 }
 
-double libmspub::MSPUBCollector::getSpecialValue(const ShapeInfo &info, const CustomShape &shape, int arg, const std::vector<int> &adjustValues) const
+double MSPUBCollector::getSpecialValue(const ShapeInfo &info, const CustomShape &shape, int arg, const std::vector<int> &adjustValues) const
 {
   if (PROP_ADJUST_VAL_FIRST <= arg && PROP_ADJUST_VAL_LAST >= arg)
   {
@@ -1050,7 +1053,7 @@ double libmspub::MSPUBCollector::getSpecialValue(const ShapeInfo &info, const Cu
   return 0;
 }
 
-double libmspub::MSPUBCollector::getCalculationValue(const ShapeInfo &info, unsigned index, bool recursiveEntry, const std::vector<int> &adjustValues) const
+double MSPUBCollector::getCalculationValue(const ShapeInfo &info, unsigned index, bool recursiveEntry, const std::vector<int> &adjustValues) const
 {
   boost::shared_ptr<const CustomShape> p_shape = info.getCustomShape();
   if (! p_shape)
@@ -1130,42 +1133,42 @@ double libmspub::MSPUBCollector::getCalculationValue(const ShapeInfo &info, unsi
   }
 }
 
-libmspub::MSPUBCollector::~MSPUBCollector()
+MSPUBCollector::~MSPUBCollector()
 {
 }
 
-void libmspub::MSPUBCollector::setShapeRotation(unsigned seqNum, double rotation)
+void MSPUBCollector::setShapeRotation(unsigned seqNum, double rotation)
 {
   m_shapeInfosBySeqNum[seqNum].m_rotation = rotation;
   m_shapeInfosBySeqNum[seqNum].m_innerRotation = (int)rotation;
 }
 
-void libmspub::MSPUBCollector::setShapeFlip(unsigned seqNum, bool flipVertical, bool flipHorizontal)
+void MSPUBCollector::setShapeFlip(unsigned seqNum, bool flipVertical, bool flipHorizontal)
 {
   m_shapeInfosBySeqNum[seqNum].m_flips = std::pair<bool, bool>(flipVertical, flipHorizontal);
 }
 
-void libmspub::MSPUBCollector::setShapeType(unsigned seqNum, ShapeType type)
+void MSPUBCollector::setShapeType(unsigned seqNum, ShapeType type)
 {
   m_shapeInfosBySeqNum[seqNum].m_type = type;
 }
 
-void libmspub::MSPUBCollector::setAdjustValue(unsigned seqNum, unsigned index, int adjust)
+void MSPUBCollector::setAdjustValue(unsigned seqNum, unsigned index, int adjust)
 {
   m_shapeInfosBySeqNum[seqNum].m_adjustValuesByIndex[index] = adjust;
 }
 
-void libmspub::MSPUBCollector::addDefaultCharacterStyle(const CharacterStyle &st)
+void MSPUBCollector::addDefaultCharacterStyle(const CharacterStyle &st)
 {
   m_defaultCharStyles.push_back(st);
 }
 
-void libmspub::MSPUBCollector::addDefaultParagraphStyle(const ParagraphStyle &st)
+void MSPUBCollector::addDefaultParagraphStyle(const ParagraphStyle &st)
 {
   m_defaultParaStyles.push_back(st);
 }
 
-bool libmspub::MSPUBCollector::addPage(unsigned seqNum)
+bool MSPUBCollector::addPage(unsigned seqNum)
 {
   if (!(m_widthSet && m_heightSet))
   {
@@ -1176,23 +1179,23 @@ bool libmspub::MSPUBCollector::addPage(unsigned seqNum)
   return true;
 }
 
-void libmspub::MSPUBCollector::addTextShape(unsigned stringId, unsigned seqNum)
+void MSPUBCollector::addTextShape(unsigned stringId, unsigned seqNum)
 {
   m_shapeInfosBySeqNum[seqNum].m_textId = stringId;
 }
 
-void libmspub::MSPUBCollector::setShapeImgIndex(unsigned seqNum, unsigned index)
+void MSPUBCollector::setShapeImgIndex(unsigned seqNum, unsigned index)
 {
   MSPUB_DEBUG_MSG(("Setting image index of shape with seqnum 0x%x to 0x%x\n", seqNum, index));
   m_shapeInfosBySeqNum[seqNum].m_imgIndex = index;
 }
 
-void libmspub::MSPUBCollector::setShapeDash(unsigned seqNum, const Dash &dash)
+void MSPUBCollector::setShapeDash(unsigned seqNum, const Dash &dash)
 {
   m_shapeInfosBySeqNum[seqNum].m_dash = dash;
 }
 
-void libmspub::MSPUBCollector::setShapeFill(unsigned seqNum, boost::shared_ptr<Fill> fill, bool skipIfNotBg)
+void MSPUBCollector::setShapeFill(unsigned seqNum, boost::shared_ptr<Fill> fill, bool skipIfNotBg)
 {
   m_shapeInfosBySeqNum[seqNum].m_fill = fill;
   if (skipIfNotBg)
@@ -1201,17 +1204,17 @@ void libmspub::MSPUBCollector::setShapeFill(unsigned seqNum, boost::shared_ptr<F
   }
 }
 
-void libmspub::MSPUBCollector::setShapeCoordinatesInEmu(unsigned seqNum, int xs, int ys, int xe, int ye)
+void MSPUBCollector::setShapeCoordinatesInEmu(unsigned seqNum, int xs, int ys, int xe, int ye)
 {
   m_shapeInfosBySeqNum[seqNum].m_coordinates = Coordinate(xs, ys, xe, ye);
 }
 
-void libmspub::MSPUBCollector::addFont(std::vector<unsigned char> name)
+void MSPUBCollector::addFont(std::vector<unsigned char> name)
 {
   m_fonts.push_back(name);
 }
 
-librevenge::RVNGPropertyList libmspub::MSPUBCollector::getParaStyleProps(const ParagraphStyle &style, boost::optional<unsigned> defaultParaStyleIndex) const
+librevenge::RVNGPropertyList MSPUBCollector::getParaStyleProps(const ParagraphStyle &style, boost::optional<unsigned> defaultParaStyleIndex) const
 {
   ParagraphStyle _nothing;
   const ParagraphStyle &defaultStyle = !!defaultParaStyleIndex && defaultParaStyleIndex.get() < m_defaultParaStyles.size() ? m_defaultParaStyles[defaultParaStyleIndex.get()] : _nothing;
@@ -1294,7 +1297,7 @@ librevenge::RVNGPropertyList libmspub::MSPUBCollector::getParaStyleProps(const P
   return ret;
 }
 
-librevenge::RVNGPropertyList libmspub::MSPUBCollector::getCharStyleProps(const CharacterStyle &style, boost::optional<unsigned> defaultCharStyleIndex) const
+librevenge::RVNGPropertyList MSPUBCollector::getCharStyleProps(const CharacterStyle &style, boost::optional<unsigned> defaultCharStyleIndex) const
 {
   CharacterStyle _nothing = CharacterStyle(false, false, false);
   if (!defaultCharStyleIndex)
@@ -1373,7 +1376,7 @@ librevenge::RVNGPropertyList libmspub::MSPUBCollector::getCharStyleProps(const C
   return ret;
 }
 
-librevenge::RVNGString libmspub::MSPUBCollector::getColorString(const Color &color)
+librevenge::RVNGString MSPUBCollector::getColorString(const Color &color)
 {
   librevenge::RVNGString ret;
   ret.sprintf("#%.2x%.2x%.2x",(unsigned char)color.r, (unsigned char)color.g, (unsigned char)color.b);
@@ -1381,7 +1384,7 @@ librevenge::RVNGString libmspub::MSPUBCollector::getColorString(const Color &col
   return ret;
 }
 
-void libmspub::MSPUBCollector::addBlackToPaletteIfNecessary()
+void MSPUBCollector::addBlackToPaletteIfNecessary()
 {
   if (m_paletteColors.size() < 8)
   {
@@ -1389,12 +1392,12 @@ void libmspub::MSPUBCollector::addBlackToPaletteIfNecessary()
   }
 }
 
-void libmspub::MSPUBCollector::assignShapesToPages()
+void MSPUBCollector::assignShapesToPages()
 {
   for (unsigned i = 0; i < m_topLevelShapes.size(); ++i)
   {
     unsigned *ptr_pageSeqNum = getIfExists(m_pageSeqNumsByShapeSeqNum, m_topLevelShapes[i].getSeqNum());
-    m_topLevelShapes[i].setup(boost::bind(&libmspub::MSPUBCollector::setupShapeStructures, this, _1));
+    m_topLevelShapes[i].setup(boost::bind(&MSPUBCollector::setupShapeStructures, this, _1));
     if (ptr_pageSeqNum)
     {
       PageInfo *ptr_page = getIfExists(m_pagesBySeqNum, *ptr_pageSeqNum);
@@ -1406,7 +1409,7 @@ void libmspub::MSPUBCollector::assignShapesToPages()
   }
 }
 
-boost::optional<unsigned> libmspub::MSPUBCollector::getMasterPageSeqNum(unsigned pageSeqNum) const
+boost::optional<unsigned> MSPUBCollector::getMasterPageSeqNum(unsigned pageSeqNum) const
 {
   boost::optional<unsigned> toReturn;
   const unsigned *ptr_masterSeqNum = getIfExists_const(m_masterPagesByPageSeqNum, pageSeqNum);
@@ -1417,7 +1420,7 @@ boost::optional<unsigned> libmspub::MSPUBCollector::getMasterPageSeqNum(unsigned
   return toReturn;
 }
 
-void libmspub::MSPUBCollector::writePage(unsigned pageSeqNum) const
+void MSPUBCollector::writePage(unsigned pageSeqNum) const
 {
   const PageInfo &pageInfo = m_pagesBySeqNum.find(pageSeqNum)->second;
   librevenge::RVNGPropertyList pageProps;
@@ -1449,18 +1452,18 @@ void libmspub::MSPUBCollector::writePage(unsigned pageSeqNum) const
   }
 }
 
-void libmspub::MSPUBCollector::writePageShapes(unsigned pageSeqNum) const
+void MSPUBCollector::writePageShapes(unsigned pageSeqNum) const
 {
   const PageInfo &pageInfo = m_pagesBySeqNum.find(pageSeqNum)->second;
   const std::vector<ShapeGroupElement *> &shapeGroupsOrdered = pageInfo.m_shapeGroupsOrdered;
   for (unsigned i = 0; i < shapeGroupsOrdered.size(); ++i)
   {
     ShapeGroupElement *shapeGroup = shapeGroupsOrdered[i];
-    shapeGroup->visit(boost::bind(&libmspub::MSPUBCollector::paintShape, this, _1, _2, _3, _4, _5));
+    shapeGroup->visit(boost::bind(&MSPUBCollector::paintShape, this, _1, _2, _3, _4, _5));
   }
 }
 
-void libmspub::MSPUBCollector::writePageBackground(unsigned pageSeqNum) const
+void MSPUBCollector::writePageBackground(unsigned pageSeqNum) const
 {
   const unsigned *ptr_fillSeqNum = getIfExists_const(m_bgShapeSeqNumsByPageSeqNum, pageSeqNum);
   if (ptr_fillSeqNum)
@@ -1484,12 +1487,12 @@ void libmspub::MSPUBCollector::writePageBackground(unsigned pageSeqNum) const
   }
 }
 
-bool libmspub::MSPUBCollector::pageIsMaster(unsigned pageSeqNum) const
+bool MSPUBCollector::pageIsMaster(unsigned pageSeqNum) const
 {
   return m_masterPages.find(pageSeqNum) != m_masterPages.end();
 }
 
-bool libmspub::MSPUBCollector::go()
+bool MSPUBCollector::go()
 {
   addBlackToPaletteIfNecessary();
   assignShapesToPages();
@@ -1522,7 +1525,7 @@ bool libmspub::MSPUBCollector::go()
 }
 
 
-bool libmspub::MSPUBCollector::addTextString(const std::vector<TextParagraph> &str, unsigned id)
+bool MSPUBCollector::addTextString(const std::vector<TextParagraph> &str, unsigned id)
 {
   MSPUB_DEBUG_MSG(("addTextString, id: 0x%x\n", id));
   m_textStringsById[id] = str;
@@ -1533,7 +1536,7 @@ bool libmspub::MSPUBCollector::addTextString(const std::vector<TextParagraph> &s
   return true; //FIXME: Warn if the string already existed in the map.
 }
 
-void libmspub::MSPUBCollector::ponderStringEncoding(
+void MSPUBCollector::ponderStringEncoding(
   const std::vector<TextParagraph> &str)
 {
   for (unsigned i = 0; i < str.size(); ++i)
@@ -1546,21 +1549,21 @@ void libmspub::MSPUBCollector::ponderStringEncoding(
   }
 }
 
-void libmspub::MSPUBCollector::setWidthInEmu(unsigned long widthInEmu)
+void MSPUBCollector::setWidthInEmu(unsigned long widthInEmu)
 {
   //FIXME: Warn if this is called twice
   m_width = ((double)widthInEmu) / EMUS_IN_INCH;
   m_widthSet = true;
 }
 
-void libmspub::MSPUBCollector::setHeightInEmu(unsigned long heightInEmu)
+void MSPUBCollector::setHeightInEmu(unsigned long heightInEmu)
 {
   //FIXME: Warn if this is called twice
   m_height = ((double)heightInEmu) / EMUS_IN_INCH;
   m_heightSet = true;
 }
 
-bool libmspub::MSPUBCollector::addImage(unsigned index, ImgType type, librevenge::RVNGBinaryData img)
+bool MSPUBCollector::addImage(unsigned index, ImgType type, librevenge::RVNGBinaryData img)
 {
   while (m_images.size() < index)
   {
@@ -1578,8 +1581,8 @@ bool libmspub::MSPUBCollector::addImage(unsigned index, ImgType type, librevenge
   return index > 0;
 }
 
-librevenge::RVNGBinaryData *libmspub::MSPUBCollector::addBorderImage(ImgType type,
-                                                                     unsigned borderArtIndex)
+librevenge::RVNGBinaryData *MSPUBCollector::addBorderImage(ImgType type,
+                                                           unsigned borderArtIndex)
 {
   while (borderArtIndex >= m_borderImages.size())
   {
@@ -1589,7 +1592,7 @@ librevenge::RVNGBinaryData *libmspub::MSPUBCollector::addBorderImage(ImgType typ
   return &(m_borderImages[borderArtIndex].m_images.back().m_imgBlob);
 }
 
-void libmspub::MSPUBCollector::setBorderImageOffset(unsigned index, unsigned offset)
+void MSPUBCollector::setBorderImageOffset(unsigned index, unsigned offset)
 {
   while (index >= m_borderImages.size())
   {
@@ -1614,30 +1617,32 @@ void libmspub::MSPUBCollector::setBorderImageOffset(unsigned index, unsigned off
   }
 }
 
-void libmspub::MSPUBCollector::setShapePage(unsigned seqNum, unsigned pageSeqNum)
+void MSPUBCollector::setShapePage(unsigned seqNum, unsigned pageSeqNum)
 {
   m_shapeInfosBySeqNum[seqNum].m_pageSeqNum = pageSeqNum;
   m_pageSeqNumsByShapeSeqNum[seqNum] = pageSeqNum;
 }
 
-void libmspub::MSPUBCollector::addTextColor(ColorReference c)
+void MSPUBCollector::addTextColor(ColorReference c)
 {
   m_textColors.push_back(c);
 }
 
-void libmspub::MSPUBCollector::designateMasterPage(unsigned seqNum)
+void MSPUBCollector::designateMasterPage(unsigned seqNum)
 {
   m_masterPages.insert(seqNum);
 }
 
-void libmspub::MSPUBCollector::setMasterPage(unsigned seqNum, unsigned masterPageSeqNum)
+void MSPUBCollector::setMasterPage(unsigned seqNum, unsigned masterPageSeqNum)
 {
   m_masterPagesByPageSeqNum[seqNum] = masterPageSeqNum;
 }
 
-void libmspub::MSPUBCollector::setShapeCropType(unsigned seqNum, ShapeType cropType)
+void MSPUBCollector::setShapeCropType(unsigned seqNum, ShapeType cropType)
 {
   m_shapeInfosBySeqNum[seqNum].m_cropType = cropType;
 }
 
+}
+
 /* vim:set shiftwidth=2 softtabstop=2 expandtab: */
diff --git a/src/lib/MSPUBDocument.cpp b/src/lib/MSPUBDocument.cpp
index 1334642..7ec0d22 100644
--- a/src/lib/MSPUBDocument.cpp
+++ b/src/lib/MSPUBDocument.cpp
@@ -19,6 +19,9 @@
 #include "MSPUBParser97.h"
 #include "libmspub_utils.h"
 
+namespace libmspub
+{
+
 namespace
 {
 
@@ -40,12 +43,12 @@ MSPUBVersion getVersion(librevenge::RVNGInputStream *input)
     if (!contentsStream)
       return MSPUB_UNKNOWN_VERSION;
 
-    if (0xe8 != libmspub::readU8(contentsStream.get()) || 0xac != libmspub::readU8(contentsStream.get()))
+    if (0xe8 != readU8(contentsStream.get()) || 0xac != readU8(contentsStream.get()))
       return MSPUB_UNKNOWN_VERSION;
 
-    unsigned char magicVersionByte = libmspub::readU8(contentsStream.get());
+    unsigned char magicVersionByte = readU8(contentsStream.get());
 
-    if (0x00 != libmspub::readU8(contentsStream.get()))
+    if (0x00 != readU8(contentsStream.get()))
       return MSPUB_UNKNOWN_VERSION;
 
     MSPUBVersion version = MSPUB_UNKNOWN_VERSION;
@@ -79,7 +82,7 @@ Analyzes the content of an input stream to see if it can be parsed
 \return A value that indicates whether the content from the input
 stream is a Microsoft Publisher Document that libmspub is able to parse
 */
-PUBAPI bool libmspub::MSPUBDocument::isSupported(librevenge::RVNGInputStream *input)
+PUBAPI bool MSPUBDocument::isSupported(librevenge::RVNGInputStream *input)
 {
   try
   {
@@ -112,7 +115,7 @@ RVNGDrawingInterface class implementation when needed. This is often commonly ca
 \param painter A MSPUBPainterInterface implementation
 \return A value that indicates whether the parsing was successful
 */
-PUBAPI bool libmspub::MSPUBDocument::parse(librevenge::RVNGInputStream *input, librevenge::RVNGDrawingInterface *painter)
+PUBAPI bool MSPUBDocument::parse(librevenge::RVNGInputStream *input, librevenge::RVNGDrawingInterface *painter)
 {
   try
   {
@@ -150,4 +153,6 @@ PUBAPI bool libmspub::MSPUBDocument::parse(librevenge::RVNGInputStream *input, l
   }
 }
 
+}
+
 /* vim:set shiftwidth=2 softtabstop=2 expandtab: */
diff --git a/src/lib/MSPUBParser.cpp b/src/lib/MSPUBParser.cpp
index e0f70d3..091f2b5 100644
--- a/src/lib/MSPUBParser.cpp
+++ b/src/lib/MSPUBParser.cpp
@@ -31,7 +31,10 @@
 #include "TableInfo.h"
 #include "VerticalAlign.h"
 
-libmspub::MSPUBParser::MSPUBParser(librevenge::RVNGInputStream *input, MSPUBCollector *collector)
+namespace libmspub
+{
+
+MSPUBParser::MSPUBParser(librevenge::RVNGInputStream *input, MSPUBCollector *collector)
   : m_input(input), m_collector(collector),
     m_blockInfo(), m_contentChunks(),
     m_cellsChunkIndices(),
@@ -44,12 +47,12 @@ libmspub::MSPUBParser::MSPUBParser(librevenge::RVNGInputStream *input, MSPUBColl
 {
 }
 
-libmspub::MSPUBParser::~MSPUBParser()
+MSPUBParser::~MSPUBParser()
 {
 }
 
-bool libmspub::MSPUBParser::lineExistsByFlagPointer(unsigned *flags,
-                                                    unsigned *geomFlags)
+bool MSPUBParser::lineExistsByFlagPointer(unsigned *flags,
+                                          unsigned *geomFlags)
 {
   return flags &&
          !(((*flags) & FLAG_USE_LINE) && !((*flags) & FLAG_LINE)) &&
@@ -58,12 +61,12 @@ bool libmspub::MSPUBParser::lineExistsByFlagPointer(unsigned *flags,
 
 }
 
-unsigned libmspub::MSPUBParser::getColorIndexByQuillEntry(unsigned entry)
+unsigned MSPUBParser::getColorIndexByQuillEntry(unsigned entry)
 {
   return entry;
 }
 
-short libmspub::MSPUBParser::getBlockDataLength(unsigned type) // -1 for variable-length block with the data length as the first DWORD
+short MSPUBParser::getBlockDataLength(unsigned type) // -1 for variable-length block with the data length as the first DWORD
 {
   switch (type)
   {
@@ -106,7 +109,7 @@ short libmspub::MSPUBParser::getBlockDataLength(unsigned type) // -1 for variabl
   return 0;
 }
 
-bool libmspub::MSPUBParser::parse()
+bool MSPUBParser::parse()
 {
   MSPUB_DEBUG_MSG(("***NOTE***: Where applicable, the meanings of block/chunk IDs and Types printed below may be found in:\n\t***MSPUBBlockType.h\n\t***MSPUBBlockID.h\n\t***MSPUBContentChunkType.h\n*****\n"));
   if (!m_input->isStructured())
@@ -160,7 +163,7 @@ bool libmspub::MSPUBParser::parse()
   return m_collector->go();
 }
 
-libmspub::ImgType libmspub::MSPUBParser::imgTypeByBlipType(unsigned short type)
+ImgType MSPUBParser::imgTypeByBlipType(unsigned short type)
 {
   switch (type)
   {
@@ -184,7 +187,7 @@ libmspub::ImgType libmspub::MSPUBParser::imgTypeByBlipType(unsigned short type)
   return UNKNOWN;
 }
 
-int libmspub::MSPUBParser::getStartOffset(ImgType type, unsigned short initial)
+int MSPUBParser::getStartOffset(ImgType type, unsigned short initial)
 {
   bool oneUid = true;
   int offset = 0x11;
@@ -225,7 +228,7 @@ int libmspub::MSPUBParser::getStartOffset(ImgType type, unsigned short initial)
   return offset + (oneUid ? 0 : 0x10);
 }
 
-bool libmspub::MSPUBParser::parseEscherDelay(librevenge::RVNGInputStream *input)
+bool MSPUBParser::parseEscherDelay(librevenge::RVNGInputStream *input)
 {
   while (stillReading(input, (unsigned long)-1))
   {
@@ -305,7 +308,7 @@ bool libmspub::MSPUBParser::parseEscherDelay(librevenge::RVNGInputStream *input)
   return true;
 }
 
-bool libmspub::MSPUBParser::parseContents(librevenge::RVNGInputStream *input)
+bool MSPUBParser::parseContents(librevenge::RVNGInputStream *input)
 {
   MSPUB_DEBUG_MSG(("MSPUBParser::parseContents\n"));
   input->seek(0x1a, librevenge::RVNG_SEEK_SET);
@@ -315,7 +318,7 @@ bool libmspub::MSPUBParser::parseContents(librevenge::RVNGInputStream *input)
   unsigned trailerLength = readU32(input);
   for (unsigned i=0; i<3; i++)
   {
-    libmspub::MSPUBBlockInfo trailerPart = parseBlock(input);
+    MSPUBBlockInfo trailerPart = parseBlock(input);
     MSPUB_DEBUG_MSG(("Trailer SubBlock %i, startPosition 0x%lx, id %i, type 0x%x, dataLength 0x%lx\n", i+1, trailerPart.startPosition, trailerPart.id, trailerPart.type, trailerPart.dataLength));
     if (trailerPart.type == TRAILER_DIRECTORY)
     {
@@ -409,9 +412,9 @@ bool libmspub::MSPUBParser::parseContents(librevenge::RVNGInputStream *input)
 }
 
 #ifdef DEBUG
-bool libmspub::MSPUBParser::parseDocumentChunk(librevenge::RVNGInputStream *input, const ContentChunkReference &chunk)
+bool MSPUBParser::parseDocumentChunk(librevenge::RVNGInputStream *input, const ContentChunkReference &chunk)
 #else
-bool libmspub::MSPUBParser::parseDocumentChunk(librevenge::RVNGInputStream *input, const ContentChunkReference &)
+bool MSPUBParser::parseDocumentChunk(librevenge::RVNGInputStream *input, const ContentChunkReference &)
 #endif
 {
   MSPUB_DEBUG_MSG(("parseDocumentChunk: offset 0x%lx, end 0x%lx\n", input->tell(), chunk.end));
@@ -419,12 +422,12 @@ bool libmspub::MSPUBParser::parseDocumentChunk(librevenge::RVNGInputStream *inpu
   unsigned long len = readU32(input);
   while (stillReading(input, begin + len))
   {
-    libmspub::MSPUBBlockInfo info = parseBlock(input);
+    MSPUBBlockInfo info = parseBlock(input);
     if (info.id == DOCUMENT_SIZE)
     {
       while (stillReading(input, info.dataOffset + info.dataLength))
       {
-        libmspub::MSPUBBlockInfo subInfo = parseBlock(input, true);
+        MSPUBBlockInfo subInfo = parseBlock(input, true);
         if (subInfo.id == DOCUMENT_WIDTH)
         {
           m_collector->setWidthInEmu(subInfo.data);
@@ -455,7 +458,7 @@ bool libmspub::MSPUBParser::parseDocumentChunk(librevenge::RVNGInputStream *inpu
   return true; //FIXME: return false for failure
 }
 
-bool libmspub::MSPUBParser::parseFontChunk(
+bool MSPUBParser::parseFontChunk(
   librevenge::RVNGInputStream *input, const ContentChunkReference &chunk)
 {
   unsigned length = readU32(input);
@@ -508,7 +511,7 @@ bool libmspub::MSPUBParser::parseFontChunk(
   return true;
 }
 
-bool libmspub::MSPUBParser::parseBorderArtChunk(
+bool MSPUBParser::parseBorderArtChunk(
   librevenge::RVNGInputStream *input, const ContentChunkReference &chunk)
 {
   unsigned length = readU32(input);
@@ -572,7 +575,7 @@ bool libmspub::MSPUBParser::parseBorderArtChunk(
   return true;
 }
 
-bool libmspub::MSPUBParser::parsePageChunk(librevenge::RVNGInputStream *input, const ContentChunkReference &chunk)
+bool MSPUBParser::parsePageChunk(librevenge::RVNGInputStream *input, const ContentChunkReference &chunk)
 {
   MSPUB_DEBUG_MSG(("parsePageChunk: offset 0x%lx, end 0x%lx, seqnum 0x%x, parent 0x%x\n", input->tell(), chunk.end, chunk.seqNum, chunk.parentSeqNum));
   unsigned long length = readU32(input);
@@ -583,7 +586,7 @@ bool libmspub::MSPUBParser::parsePageChunk(librevenge::RVNGInputStream *input, c
   }
   while (stillReading(input, chunk.offset + length))
   {
-    libmspub::MSPUBBlockInfo info = parseBlock(input);
+    MSPUBBlockInfo info = parseBlock(input);
     if (info.id == PAGE_BG_SHAPE)
     {
       m_collector->setPageBgShape(chunk.seqNum, info.data);
@@ -614,12 +617,12 @@ bool libmspub::MSPUBParser::parsePageChunk(librevenge::RVNGInputStream *input, c
   return true;
 }
 
-bool libmspub::MSPUBParser::parsePageShapeList(librevenge::RVNGInputStream *input, libmspub::MSPUBBlockInfo info, unsigned pageSeqNum)
+bool MSPUBParser::parsePageShapeList(librevenge::RVNGInputStream *input, MSPUBBlockInfo info, unsigned pageSeqNum)
 {
   MSPUB_DEBUG_MSG(("parsePageShapeList: page seqnum 0x%x\n", pageSeqNum));
   while (stillReading(input, info.dataOffset + info.dataLength))
   {
-    libmspub::MSPUBBlockInfo subInfo = parseBlock(input, true);
+    MSPUBBlockInfo subInfo = parseBlock(input, true);
     if (subInfo.type == SHAPE_SEQNUM)
     {
       m_collector->setShapePage(subInfo.data, pageSeqNum);
@@ -628,8 +631,8 @@ bool libmspub::MSPUBParser::parsePageShapeList(librevenge::RVNGInputStream *inpu
   return true;
 }
 
-bool libmspub::MSPUBParser::parseShape(librevenge::RVNGInputStream *input,
-                                       const ContentChunkReference &chunk)
+bool MSPUBParser::parseShape(librevenge::RVNGInputStream *input,
+                             const ContentChunkReference &chunk)
 {
   MSPUB_DEBUG_MSG(("parseShape: seqNum 0x%x\n", chunk.seqNum));
   unsigned long pos = input->tell();
@@ -646,7 +649,7 @@ bool libmspub::MSPUBParser::parseShape(librevenge::RVNGInputStream *input,
     boost::optional<unsigned> rowcolArrayOffset;
     while (stillReading(input, pos + length))
     {
-      libmspub::MSPUBBlockInfo info = parseBlock(input, true);
+      MSPUBBlockInfo info = parseBlock(input, true);
       if (info.id == TABLE_WIDTH)
       {
         width = info.data;
@@ -755,7 +758,7 @@ bool libmspub::MSPUBParser::parseShape(librevenge::RVNGInputStream *input,
     unsigned textId = 0;
     while (stillReading(input, pos + length))
     {
-      libmspub::MSPUBBlockInfo info = parseBlock(input, true);
+      MSPUBBlockInfo info = parseBlock(input, true);
       if (info.id == SHAPE_WIDTH)
       {
         width = info.data;
@@ -811,9 +814,9 @@ bool libmspub::MSPUBParser::parseShape(librevenge::RVNGInputStream *input,
   }
 }
 
-libmspub::QuillChunkReference libmspub::MSPUBParser::parseQuillChunkReference(librevenge::RVNGInputStream *input)
+QuillChunkReference MSPUBParser::parseQuillChunkReference(librevenge::RVNGInputStream *input)
 {
-  libmspub::QuillChunkReference ret;
+  QuillChunkReference ret;
   readU16(input); //FIXME: Can we do something sensible if this is not 0x18 ?
   char name[5];
   for (int i = 0; i < 4; ++i)
@@ -836,7 +839,7 @@ libmspub::QuillChunkReference libmspub::MSPUBParser::parseQuillChunkReference(li
   return ret;
 }
 
-std::vector<unsigned> libmspub::MSPUBParser::parseTableCellDefinitions(
+std::vector<unsigned> MSPUBParser::parseTableCellDefinitions(
   librevenge::RVNGInputStream *input, const QuillChunkReference &chunk)
 {
   std::vector<unsigned> ret;
@@ -854,7 +857,7 @@ std::vector<unsigned> libmspub::MSPUBParser::parseTableCellDefinitions(
   return ret;
 }
 
-bool libmspub::MSPUBParser::parseQuill(librevenge::RVNGInputStream *input)
+bool MSPUBParser::parseQuill(librevenge::RVNGInputStream *input)
 {
   MSPUB_DEBUG_MSG(("MSPUBParser::parseQuill\n"));
   unsigned chunkReferenceListOffset = 0x18;
@@ -866,7 +869,7 @@ bool libmspub::MSPUBParser::parseQuill(librevenge::RVNGInputStream *input)
     chunkReferenceListOffset = readU32(input);
     for (unsigned i = 0; i < numChunks; ++i)
     {
-      libmspub::QuillChunkReference quillChunkReference = parseQuillChunkReference(input);
+      QuillChunkReference quillChunkReference = parseQuillChunkReference(input);
       chunkReferences.push_back(quillChunkReference);
     }
   }
@@ -1021,7 +1024,7 @@ bool libmspub::MSPUBParser::parseQuill(librevenge::RVNGInputStream *input)
   return true;
 }
 
-void libmspub::MSPUBParser::parseFonts(librevenge::RVNGInputStream *input, const QuillChunkReference &)
+void MSPUBParser::parseFonts(librevenge::RVNGInputStream *input, const QuillChunkReference &)
 {
   readU32(input);
   unsigned numElements = readU32(input);
@@ -1039,7 +1042,7 @@ void libmspub::MSPUBParser::parseFonts(librevenge::RVNGInputStream *input, const
   }
 }
 
-void libmspub::MSPUBParser::parseDefaultStyle(librevenge::RVNGInputStream *input, const QuillChunkReference &chunk)
+void MSPUBParser::parseDefaultStyle(librevenge::RVNGInputStream *input, const QuillChunkReference &chunk)
 {
   readU32(input);
   unsigned numElements = readU32(input);
@@ -1067,7 +1070,7 @@ void libmspub::MSPUBParser::parseDefaultStyle(librevenge::RVNGInputStream *input
 }
 
 
-void libmspub::MSPUBParser::parseColors(librevenge::RVNGInputStream *input, const QuillChunkReference &)
+void MSPUBParser::parseColors(librevenge::RVNGInputStream *input, const QuillChunkReference &)
 {
   unsigned numEntries = readU32(input);
   input->seek(input->tell() + 8, librevenge::RVNG_SEEK_SET);
@@ -1086,7 +1089,7 @@ void libmspub::MSPUBParser::parseColors(librevenge::RVNGInputStream *input, cons
   }
 }
 
-std::vector<libmspub::MSPUBParser::TextParagraphReference> libmspub::MSPUBParser::parseParagraphStyles(librevenge::RVNGInputStream *input, const QuillChunkReference &chunk)
+std::vector<MSPUBParser::TextParagraphReference> MSPUBParser::parseParagraphStyles(librevenge::RVNGInputStream *input, const QuillChunkReference &chunk)
 {
   std::vector<TextParagraphReference> ret;
   unsigned short numEntries = readU16(input);
@@ -1114,7 +1117,7 @@ std::vector<libmspub::MSPUBParser::TextParagraphReference> libmspub::MSPUBParser
   return ret;
 }
 
-std::vector<libmspub::MSPUBParser::TextSpanReference> libmspub::MSPUBParser::parseCharacterStyles(librevenge::RVNGInputStream *input, const QuillChunkReference &chunk)
+std::vector<MSPUBParser::TextSpanReference> MSPUBParser::parseCharacterStyles(librevenge::RVNGInputStream *input, const QuillChunkReference &chunk)
 {
   unsigned short numEntries = readU16(input);
   input->seek(input->tell() + 6, librevenge::RVNG_SEEK_SET);
@@ -1141,7 +1144,7 @@ std::vector<libmspub::MSPUBParser::TextSpanReference> libmspub::MSPUBParser::par
   }
   return ret;
 }
-libmspub::ParagraphStyle libmspub::MSPUBParser::getParagraphStyle(librevenge::RVNGInputStream *input)
+ParagraphStyle MSPUBParser::getParagraphStyle(librevenge::RVNGInputStream *input)
 {
   ParagraphStyle ret;
 
@@ -1271,7 +1274,7 @@ libmspub::ParagraphStyle libmspub::MSPUBParser::getParagraphStyle(librevenge::RV
   return ret;
 }
 
-libmspub::CharacterStyle libmspub::MSPUBParser::getCharacterStyle(librevenge::RVNGInputStream *input)
+CharacterStyle MSPUBParser::getCharacterStyle(librevenge::RVNGInputStream *input)
 {
   bool seenUnderline = false, seenBold1 = false, seenBold2 = false, seenItalic1 = false, seenItalic2 = false;
   int textSize1 = -1, /* textSize2 = -1,*/ colorIndex = -1;
@@ -1281,7 +1284,7 @@ libmspub::CharacterStyle libmspub::MSPUBParser::getCharacterStyle(librevenge::RV
   unsigned len = readU32(input);
   while (stillReading(input, offset + len))
   {
-    libmspub::MSPUBBlockInfo info = parseBlock(input, true);
+    MSPUBBlockInfo info = parseBlock(input, true);
     switch (info.id)
     {
     case BOLD_1_ID:
@@ -1331,7 +1334,7 @@ libmspub::CharacterStyle libmspub::MSPUBParser::getCharacterStyle(librevenge::RV
   return CharacterStyle(seenUnderline, seenItalic1 && seenItalic2, seenBold1 && seenBold2, dTextSize, getColorIndexByQuillEntry(colorIndex), fontIndex, sst);
 }
 
-unsigned libmspub::MSPUBParser::getFontIndex(librevenge::RVNGInputStream *input, const MSPUBBlockInfo &info)
+unsigned MSPUBParser::getFontIndex(librevenge::RVNGInputStream *input, const MSPUBBlockInfo &info)
 {
   MSPUB_DEBUG_MSG(("In getFontIndex\n"));
   input->seek(info.dataOffset + 4, librevenge::RVNG_SEEK_SET);
@@ -1352,7 +1355,7 @@ unsigned libmspub::MSPUBParser::getFontIndex(librevenge::RVNGInputStream *input,
   return 0;
 }
 
-int libmspub::MSPUBParser::getColorIndex(librevenge::RVNGInputStream *input, const MSPUBBlockInfo &info)
+int MSPUBParser::getColorIndex(librevenge::RVNGInputStream *input, const MSPUBBlockInfo &info)
 {
   input->seek(info.dataOffset + 4, librevenge::RVNG_SEEK_SET);
   while (stillReading(input, info.dataOffset + info.dataLength))
@@ -1369,19 +1372,19 @@ int libmspub::MSPUBParser::getColorIndex(librevenge::RVNGInputStream *input, con
   return -1;
 }
 
-bool libmspub::MSPUBParser::parseEscher(librevenge::RVNGInputStream *input)
+bool MSPUBParser::parseEscher(librevenge::RVNGInputStream *input)
 {
   MSPUB_DEBUG_MSG(("MSPUBParser::parseEscher\n"));
-  libmspub::EscherContainerInfo fakeroot;
+  EscherContainerInfo fakeroot;
   fakeroot.initial = 0;
   fakeroot.type = 0;
   fakeroot.contentsOffset = input->tell();
   fakeroot.contentsLength = (unsigned long)-1; //FIXME: Get the actual length
-  libmspub::EscherContainerInfo dg, dgg;
+  EscherContainerInfo dg, dgg;
   //Note: this assumes that dgg comes before any dg with images.
   if (findEscherContainer(input, fakeroot, dgg, OFFICE_ART_DGG_CONTAINER))
   {
-    libmspub::EscherContainerInfo bsc;
+    EscherContainerInfo bsc;
     if (findEscherContainer(input, fakeroot, bsc, OFFICE_ART_B_STORE_CONTAINER))
     {
       unsigned short currentDelayIndex = 1;
@@ -1404,7 +1407,7 @@ bool libmspub::MSPUBParser::parseEscher(librevenge::RVNGInputStream *input)
   }
   while (findEscherContainer(input, fakeroot, dg, OFFICE_ART_DG_CONTAINER))
   {
-    libmspub::EscherContainerInfo spgr;
+    EscherContainerInfo spgr;
     while (findEscherContainer(input, dg, spgr, OFFICE_ART_SPGR_CONTAINER))
     {
       Coordinate c1, c2;
@@ -1415,9 +1418,9 @@ bool libmspub::MSPUBParser::parseEscher(librevenge::RVNGInputStream *input)
   return true;
 }
 
-void libmspub::MSPUBParser::parseShapeGroup(librevenge::RVNGInputStream *input, const EscherContainerInfo &spgr, Coordinate parentCoordinateSystem, Coordinate parentGroupAbsoluteCoord)
+void MSPUBParser::parseShapeGroup(librevenge::RVNGInputStream *input, const EscherContainerInfo &spgr, Coordinate parentCoordinateSystem, Coordinate parentGroupAbsoluteCoord)
 {
-  libmspub::EscherContainerInfo shapeOrGroup;
+  EscherContainerInfo shapeOrGroup;
   std::set<unsigned short> types;
   types.insert(OFFICE_ART_SPGR_CONTAINER);
   types.insert(OFFICE_ART_SP_CONTAINER);
@@ -1438,16 +1441,16 @@ void libmspub::MSPUBParser::parseShapeGroup(librevenge::RVNGInputStream *input,
   }
 }
 
-void libmspub::MSPUBParser::parseEscherShape(librevenge::RVNGInputStream *input, const EscherContainerInfo &sp, Coordinate &parentCoordinateSystem, Coordinate &parentGroupAbsoluteCoord)
+void MSPUBParser::parseEscherShape(librevenge::RVNGInputStream *input, const EscherContainerInfo &sp, Coordinate &parentCoordinateSystem, Coordinate &parentGroupAbsoluteCoord)
 {
   Coordinate thisParentCoordinateSystem = parentCoordinateSystem;
   bool definesRelativeCoordinates = false;
-  libmspub::EscherContainerInfo cData;
-  libmspub::EscherContainerInfo cAnchor;
-  libmspub::EscherContainerInfo cFopt;
-  libmspub::EscherContainerInfo cTertiaryFopt;
-  libmspub::EscherContainerInfo cFsp;
-  libmspub::EscherContainerInfo cFspgr;
+  EscherContainerInfo cData;
+  EscherContainerInfo cAnchor;
+  EscherContainerInfo cFopt;
+  EscherContainerInfo cTertiaryFopt;
+  EscherContainerInfo cFsp;
+  EscherContainerInfo cFspgr;
   unsigned shapeFlags = 0;
   bool isGroupLeader = false;
   ShapeType st = RECTANGLE;
@@ -1773,7 +1776,7 @@ void libmspub::MSPUBParser::parseEscherShape(librevenge::RVNGInputStream *input,
           const std::vector<unsigned char> wrapVertexData = foptValues.m_complexValues[FIELDID_P_WRAPPOLYGONVERTICES];
           if (!wrapVertexData.empty())
           {
-            std::vector<libmspub::Vertex> ret = parseVertices(wrapVertexData);
+            std::vector<Vertex> ret = parseVertices(wrapVertexData);
             m_collector->setShapeClipPath(*shapeSeqNum, ret);
           }
         }
@@ -1832,8 +1835,8 @@ void libmspub::MSPUBParser::parseEscherShape(librevenge::RVNGInputStream *input,
   }
 }
 
-boost::shared_ptr<libmspub::Fill> libmspub::MSPUBParser::getNewFill(const std::map<unsigned short, unsigned> &foptProperties,
-                                                                    bool &skipIfNotBg, std::map<unsigned short, std::vector<unsigned char> > &foptValues)
+boost::shared_ptr<Fill> MSPUBParser::getNewFill(const std::map<unsigned short, unsigned> &foptProperties,
+                                                bool &skipIfNotBg, std::map<unsigned short, std::vector<unsigned char> > &foptValues)
 {
   const FillType *ptr_fillType = (FillType *)getIfExists_const(foptProperties, FIELDID_FILL_TYPE);
   FillType fillType = ptr_fillType ? *ptr_fillType : SOLID;
@@ -2001,7 +2004,7 @@ boost::shared_ptr<libmspub::Fill> libmspub::MSPUBParser::getNewFill(const std::m
   }
 }
 
-libmspub::DynamicCustomShape libmspub::MSPUBParser::getDynamicCustomShape(
+DynamicCustomShape MSPUBParser::getDynamicCustomShape(
   const std::vector<unsigned char> &vertexData, const std::vector<unsigned char> &segmentData,
   const std::vector<unsigned char> &guideData, unsigned geoWidth,
   unsigned geoHeight)
@@ -2013,7 +2016,7 @@ libmspub::DynamicCustomShape libmspub::MSPUBParser::getDynamicCustomShape(
   return ret;
 }
 
-std::vector<unsigned short> libmspub::MSPUBParser::parseSegments(
+std::vector<unsigned short> MSPUBParser::parseSegments(
   const std::vector<unsigned char> &segmentData)
 {
   std::vector<unsigned short> ret;
@@ -2036,7 +2039,7 @@ std::vector<unsigned short> libmspub::MSPUBParser::parseSegments(
   return ret;
 }
 
-std::vector<libmspub::Calculation> libmspub::MSPUBParser::parseGuides(
+std::vector<Calculation> MSPUBParser::parseGuides(
   const std::vector<unsigned char> &/* guideData */)
 {
   std::vector<Calculation> ret;
@@ -2046,10 +2049,10 @@ std::vector<libmspub::Calculation> libmspub::MSPUBParser::parseGuides(
   return ret;
 }
 
-std::vector<libmspub::Vertex> libmspub::MSPUBParser::parseVertices(
+std::vector<Vertex> MSPUBParser::parseVertices(
   const std::vector<unsigned char> &vertexData)
 {
-  std::vector<libmspub::Vertex> ret;
+  std::vector<Vertex> ret;
   if (vertexData.size() < 6)
   {
     return ret;
@@ -2095,14 +2098,14 @@ std::vector<libmspub::Vertex> libmspub::MSPUBParser::parseVertices(
       y = 0;
       break;
     }
-    libmspub::Vertex v = {x, y};
+    Vertex v = {x, y};
     ret.push_back(v);
     offset += entrySize;
   }
   return ret;
 }
 
-unsigned libmspub::MSPUBParser::getEscherElementTailLength(unsigned short type)
+unsigned MSPUBParser::getEscherElementTailLength(unsigned short type)
 {
   switch (type)
   {
@@ -2114,7 +2117,7 @@ unsigned libmspub::MSPUBParser::getEscherElementTailLength(unsigned short type)
   }
 }
 
-unsigned libmspub::MSPUBParser::getEscherElementAdditionalHeaderLength(unsigned short type)
+unsigned MSPUBParser::getEscherElementAdditionalHeaderLength(unsigned short type)
 {
   switch (type)
   {
@@ -2125,11 +2128,11 @@ unsigned libmspub::MSPUBParser::getEscherElementAdditionalHeaderLength(unsigned
   return 0;
 }
 
-bool libmspub::MSPUBParser::findEscherContainerWithTypeInSet(librevenge::RVNGInputStream *input, const libmspub::EscherContainerInfo &parent, libmspub::EscherContainerInfo &out, std::set<unsigned short> types)
+bool MSPUBParser::findEscherContainerWithTypeInSet(librevenge::RVNGInputStream *input, const EscherContainerInfo &parent, EscherContainerInfo &out, std::set<unsigned short> types)
 {
   while (stillReading(input, parent.contentsOffset + parent.contentsLength))
   {
-    libmspub::EscherContainerInfo next = parseEscherContainer(input);
+    EscherContainerInfo next = parseEscherContainer(input);
     if (types.find(next.type) != types.end())
     {
       out = next;
@@ -2140,12 +2143,12 @@ bool libmspub::MSPUBParser::findEscherContainerWithTypeInSet(librevenge::RVNGInp
   return false;
 }
 
-bool libmspub::MSPUBParser::findEscherContainer(librevenge::RVNGInputStream *input, const libmspub::EscherContainerInfo &parent, libmspub::EscherContainerInfo &out, unsigned short desiredType)
+bool MSPUBParser::findEscherContainer(librevenge::RVNGInputStream *input, const EscherContainerInfo &parent, EscherContainerInfo &out, unsigned short desiredType)
 {
   MSPUB_DEBUG_MSG(("At offset 0x%lx, attempting to find escher container of type 0x%x\n", input->tell(), desiredType));
   while (stillReading(input, parent.contentsOffset + parent.contentsLength))
   {
-    libmspub::EscherContainerInfo next = parseEscherContainer(input);
+    EscherContainerInfo next = parseEscherContainer(input);
     if (next.type == desiredType)
     {
       out = next;
@@ -2156,7 +2159,7 @@ bool libmspub::MSPUBParser::findEscherContainer(librevenge::RVNGInputStream *inp
   return false;
 }
 
-libmspub::FOPTValues libmspub::MSPUBParser::extractFOPTValues(librevenge::RVNGInputStream *input, const libmspub::EscherContainerInfo &record)
+FOPTValues MSPUBParser::extractFOPTValues(librevenge::RVNGInputStream *input, const EscherContainerInfo &record)
 {
   FOPTValues ret;
   input->seek(record.contentsOffset, librevenge::RVNG_SEEK_SET);
@@ -2202,7 +2205,7 @@ libmspub::FOPTValues libmspub::MSPUBParser::extractFOPTValues(librevenge::RVNGIn
   return ret;
 }
 
-std::map<unsigned short, unsigned> libmspub::MSPUBParser::extractEscherValues(librevenge::RVNGInputStream *input, const libmspub::EscherContainerInfo &record)
+std::map<unsigned short, unsigned> MSPUBParser::extractEscherValues(librevenge::RVNGInputStream *input, const EscherContainerInfo &record)
 {
   std::map<unsigned short, unsigned> ret;
   input->seek(record.contentsOffset + getEscherElementAdditionalHeaderLength(record.type), librevenge::RVNG_SEEK_SET);
@@ -2216,11 +2219,11 @@ std::map<unsigned short, unsigned> libmspub::MSPUBParser::extractEscherValues(li
 }
 
 
-bool libmspub::MSPUBParser::parseContentChunkReference(librevenge::RVNGInputStream *input, const libmspub::MSPUBBlockInfo block)
+bool MSPUBParser::parseContentChunkReference(librevenge::RVNGInputStream *input, const MSPUBBlockInfo block)
 {
   //input should be at block.dataOffset + 4 , that is, at the beginning of the list of sub-blocks
   MSPUB_DEBUG_MSG(("Parsing chunk reference 0x%x\n", m_lastSeenSeqNum));
-  libmspub::MSPUBContentChunkType type = (libmspub::MSPUBContentChunkType)0;
+  MSPUBContentChunkType type = (MSPUBContentChunkType)0;
   unsigned long offset = 0;
   unsigned parentSeqNum = 0;
   bool seenType = false;
@@ -2228,11 +2231,11 @@ bool libmspub::MSPUBParser::parseContentChunkReference(librevenge::RVNGInputStre
   bool seenParentSeqNum = false;
   while (stillReading(input, block.dataOffset + block.dataLength))
   {
-    libmspub::MSPUBBlockInfo subBlock = parseBlock(input, true);
+    MSPUBBlockInfo subBlock = parseBlock(input, true);
     //FIXME: Warn if multiple of these blocks seen.
     if (subBlock.id == CHUNK_TYPE)
     {
-      type = (libmspub::MSPUBContentChunkType)subBlock.data;
+      type = (MSPUBContentChunkType)subBlock.data;
       seenType = true;
     }
     else if (subBlock.id == CHUNK_OFFSET)
@@ -2307,18 +2310,18 @@ bool libmspub::MSPUBParser::parseContentChunkReference(librevenge::RVNGInputStre
   return false;
 }
 
-bool libmspub::MSPUBParser::isBlockDataString(unsigned type)
+bool MSPUBParser::isBlockDataString(unsigned type)
 {
   return type == STRING_CONTAINER;
 }
-void libmspub::MSPUBParser::skipBlock(librevenge::RVNGInputStream *input, libmspub::MSPUBBlockInfo block)
+void MSPUBParser::skipBlock(librevenge::RVNGInputStream *input, MSPUBBlockInfo block)
 {
   input->seek(block.dataOffset + block.dataLength, librevenge::RVNG_SEEK_SET);
 }
 
-libmspub::EscherContainerInfo libmspub::MSPUBParser::parseEscherContainer(librevenge::RVNGInputStream *input)
+EscherContainerInfo MSPUBParser::parseEscherContainer(librevenge::RVNGInputStream *input)
 {
-  libmspub::EscherContainerInfo info;
+  EscherContainerInfo info;
   info.initial = readU16(input);
   info.type = readU16(input);
   info.contentsLength = readU32(input);
@@ -2327,9 +2330,9 @@ libmspub::EscherContainerInfo libmspub::MSPUBParser::parseEscherContainer(librev
   return info;
 }
 
-libmspub::MSPUBBlockInfo libmspub::MSPUBParser::parseBlock(librevenge::RVNGInputStream *input, bool skipHierarchicalData)
+MSPUBBlockInfo MSPUBParser::parseBlock(librevenge::RVNGInputStream *input, bool skipHierarchicalData)
 {
-  libmspub::MSPUBBlockInfo info;
+  MSPUBBlockInfo info;
   info.startPosition = input->tell();
   info.id = (MSPUBBlockID)readU8(input);
   info.type = (MSPUBBlockType)readU8(input);
@@ -2378,7 +2381,7 @@ libmspub::MSPUBBlockInfo libmspub::MSPUBParser::parseBlock(librevenge::RVNGInput
   return info;
 }
 
-libmspub::PageType libmspub::MSPUBParser::getPageTypeBySeqNum(unsigned seqNum)
+PageType MSPUBParser::getPageTypeBySeqNum(unsigned seqNum)
 {
   switch (seqNum)
   {
@@ -2392,7 +2395,7 @@ libmspub::PageType libmspub::MSPUBParser::getPageTypeBySeqNum(unsigned seqNum)
   }
 }
 
-bool libmspub::MSPUBParser::parsePaletteChunk(librevenge::RVNGInputStream *input, const ContentChunkReference &chunk)
+bool MSPUBParser::parsePaletteChunk(librevenge::RVNGInputStream *input, const ContentChunkReference &chunk)
 {
   unsigned length = readU32(input);
   while (stillReading(input, chunk.offset + length))
@@ -2419,7 +2422,7 @@ bool libmspub::MSPUBParser::parsePaletteChunk(librevenge::RVNGInputStream *input
   return true;
 }
 
-void libmspub::MSPUBParser::parsePaletteEntry(librevenge::RVNGInputStream *input, MSPUBBlockInfo info)
+void MSPUBParser::parsePaletteEntry(librevenge::RVNGInputStream *input, MSPUBBlockInfo info)
 {
   while (stillReading(input, info.dataOffset + info.dataLength))
   {
@@ -2431,4 +2434,6 @@ void libmspub::MSPUBParser::parsePaletteEntry(librevenge::RVNGInputStream *input
   }
 }
 
+}
+
 /* vim:set shiftwidth=2 softtabstop=2 expandtab: */
diff --git a/src/lib/MSPUBParser2k.cpp b/src/lib/MSPUBParser2k.cpp
index c068dc5..a206c63 100644
--- a/src/lib/MSPUBParser2k.cpp
+++ b/src/lib/MSPUBParser2k.cpp
@@ -19,7 +19,10 @@
 #include "libmspub_utils.h"
 #include "MSPUBCollector.h"
 
-libmspub::MSPUBParser2k::MSPUBParser2k(librevenge::RVNGInputStream *input, MSPUBCollector *collector)
+namespace libmspub
+{
+
+MSPUBParser2k::MSPUBParser2k(librevenge::RVNGInputStream *input, MSPUBCollector *collector)
   : MSPUBParser(input, collector),
     m_imageDataChunkIndices(),
     m_quillColorEntries(),
@@ -27,7 +30,7 @@ libmspub::MSPUBParser2k::MSPUBParser2k(librevenge::RVNGInputStream *input, MSPUB
 {
 }
 
-unsigned libmspub::MSPUBParser2k::getColorIndexByQuillEntry(unsigned entry)
+unsigned MSPUBParser2k::getColorIndexByQuillEntry(unsigned entry)
 {
   unsigned translation = translate2kColorReference(entry);
   std::vector<unsigned>::const_iterator i_entry = std::find(m_quillColorEntries.begin(), m_quillColorEntries.end(), translation);
@@ -40,7 +43,7 @@ unsigned libmspub::MSPUBParser2k::getColorIndexByQuillEntry(unsigned entry)
   return i_entry - m_quillColorEntries.begin();
 }
 
-libmspub::MSPUBParser2k::~MSPUBParser2k()
+MSPUBParser2k::~MSPUBParser2k()
 {
 }
 
@@ -61,7 +64,7 @@ unsigned short translateLineWidth(unsigned char lineWidth)
   }
 }
 
-libmspub::Color libmspub::MSPUBParser2k::getColorBy2kHex(unsigned hex)
+Color MSPUBParser2k::getColorBy2kHex(unsigned hex)
 {
   switch ((hex >> 24) & 0xFF)
   {
@@ -76,7 +79,7 @@ libmspub::Color libmspub::MSPUBParser2k::getColorBy2kHex(unsigned hex)
   }
 }
 
-libmspub::Color libmspub::MSPUBParser2k::getColorBy2kIndex(unsigned char index)
+Color MSPUBParser2k::getColorBy2kIndex(unsigned char index)
 {
   switch (index)
   {
@@ -198,7 +201,7 @@ libmspub::Color libmspub::MSPUBParser2k::getColorBy2kIndex(unsigned char index)
 }
 
 // takes a color reference in 2k format and translates it into 2k2 format that collector understands.
-unsigned libmspub::MSPUBParser2k::translate2kColorReference(unsigned ref2k)
+unsigned MSPUBParser2k::translate2kColorReference(unsigned ref2k)
 {
   switch ((ref2k >> 24) & 0xFF)
   {
@@ -214,7 +217,7 @@ unsigned libmspub::MSPUBParser2k::translate2kColorReference(unsigned ref2k)
 }
 
 //FIXME: Valek found different values; what does this depend on?
-libmspub::ShapeType libmspub::MSPUBParser2k::getShapeType(unsigned char shapeSpecifier)
+ShapeType MSPUBParser2k::getShapeType(unsigned char shapeSpecifier)
 {
   switch (shapeSpecifier)
   {
@@ -310,11 +313,11 @@ libmspub::ShapeType libmspub::MSPUBParser2k::getShapeType(unsigned char shapeSpe
   }
 }
 
-void libmspub::MSPUBParser2k::parseContentsTextIfNecessary(librevenge::RVNGInputStream *)
+void MSPUBParser2k::parseContentsTextIfNecessary(librevenge::RVNGInputStream *)
 {
 }
 
-bool libmspub::MSPUBParser2k::parseContents(librevenge::RVNGInputStream *input)
+bool MSPUBParser2k::parseContents(librevenge::RVNGInputStream *input)
 {
   parseContentsTextIfNecessary(input);
   input->seek(0x16, librevenge::RVNG_SEEK_SET);
@@ -442,7 +445,7 @@ bool libmspub::MSPUBParser2k::parseContents(librevenge::RVNGInputStream *input)
   return true;
 }
 
-bool libmspub::MSPUBParser2k::parseDocument(librevenge::RVNGInputStream *input)
+bool MSPUBParser2k::parseDocument(librevenge::RVNGInputStream *input)
 {
   if (!!m_documentChunkIndex)
   {
@@ -457,8 +460,8 @@ bool libmspub::MSPUBParser2k::parseDocument(librevenge::RVNGInputStream *input)
   return false;
 }
 
-void libmspub::MSPUBParser2k::parseShapeRotation(librevenge::RVNGInputStream *input, bool isGroup, bool isLine,
-                                                 unsigned seqNum, unsigned chunkOffset)
+void MSPUBParser2k::parseShapeRotation(librevenge::RVNGInputStream *input, bool isGroup, bool isLine,
+                                       unsigned seqNum, unsigned chunkOffset)
 {
   input->seek(chunkOffset + 4, librevenge::RVNG_SEEK_SET);
   // shape transforms are NOT compounded with group transforms. They are equal to what they would be
@@ -473,8 +476,8 @@ void libmspub::MSPUBParser2k::parseShapeRotation(librevenge::RVNGInputStream *in
   }
 }
 
-bool libmspub::MSPUBParser2k::parse2kShapeChunk(const ContentChunkReference &chunk, librevenge::RVNGInputStream *input,
-                                                boost::optional<unsigned> pageSeqNum, bool topLevelCall)
+bool MSPUBParser2k::parse2kShapeChunk(const ContentChunkReference &chunk, librevenge::RVNGInputStream *input,
+                                      boost::optional<unsigned> pageSeqNum, bool topLevelCall)
 {
   unsigned page = pageSeqNum.get_value_or(chunk.parentSeqNum);
   input->seek(chunk.offset, librevenge::RVNG_SEEK_SET);
@@ -533,17 +536,17 @@ bool libmspub::MSPUBParser2k::parse2kShapeChunk(const ContentChunkReference &chu
   return true;
 }
 
-unsigned libmspub::MSPUBParser2k::getShapeFillTypeOffset() const
+unsigned MSPUBParser2k::getShapeFillTypeOffset() const
 {
   return 0x2A;
 }
 
-unsigned libmspub::MSPUBParser2k::getShapeFillColorOffset() const
+unsigned MSPUBParser2k::getShapeFillColorOffset() const
 {
   return 0x22;
 }
 
-void libmspub::MSPUBParser2k::parseShapeFill(librevenge::RVNGInputStream *input, unsigned seqNum, unsigned chunkOffset)
+void MSPUBParser2k::parseShapeFill(librevenge::RVNGInputStream *input, unsigned seqNum, unsigned chunkOffset)
 {
   input->seek(chunkOffset + getShapeFillTypeOffset(), librevenge::RVNG_SEEK_SET);
   unsigned char fillType = readU8(input);
@@ -556,7 +559,7 @@ void libmspub::MSPUBParser2k::parseShapeFill(librevenge::RVNGInputStream *input,
   }
 }
 
-bool libmspub::MSPUBParser2k::parseGroup(librevenge::RVNGInputStream *input, unsigned seqNum, unsigned page)
+bool MSPUBParser2k::parseGroup(librevenge::RVNGInputStream *input, unsigned seqNum, unsigned page)
 {
   bool retVal = true;
   m_collector->beginGroup();
@@ -573,7 +576,7 @@ bool libmspub::MSPUBParser2k::parseGroup(librevenge::RVNGInputStream *input, uns
   return retVal;
 }
 
-void libmspub::MSPUBParser2k::assignShapeImgIndex(unsigned seqNum)
+void MSPUBParser2k::assignShapeImgIndex(unsigned seqNum)
 {
   int i_dataIndex = -1;
   for (unsigned j = 0; j < m_imageDataChunkIndices.size(); ++j)
@@ -590,8 +593,8 @@ void libmspub::MSPUBParser2k::assignShapeImgIndex(unsigned seqNum)
   }
 }
 
-void libmspub::MSPUBParser2k::parseShapeCoordinates(librevenge::RVNGInputStream *input, unsigned seqNum,
-                                                    unsigned chunkOffset)
+void MSPUBParser2k::parseShapeCoordinates(librevenge::RVNGInputStream *input, unsigned seqNum,
+                                          unsigned chunkOffset)
 {
   input->seek(chunkOffset + 6, librevenge::RVNG_SEEK_SET);
   int xs = translateCoordinateIfNecessary(readS32(input));
@@ -601,13 +604,13 @@ void libmspub::MSPUBParser2k::parseShapeCoordinates(librevenge::RVNGInputStream
   m_collector->setShapeCoordinatesInEmu(seqNum, xs, ys, xe, ye);
 }
 
-int libmspub::MSPUBParser2k::translateCoordinateIfNecessary(int coordinate) const
+int MSPUBParser2k::translateCoordinateIfNecessary(int coordinate) const
 {
   return coordinate;
 }
 
-void libmspub::MSPUBParser2k::parseShapeFlips(librevenge::RVNGInputStream *input, unsigned flagsOffset, unsigned seqNum,
-                                              unsigned chunkOffset)
+void MSPUBParser2k::parseShapeFlips(librevenge::RVNGInputStream *input, unsigned flagsOffset, unsigned seqNum,
+                                    unsigned chunkOffset)
 {
   if (flagsOffset)
   {
@@ -619,10 +622,10 @@ void libmspub::MSPUBParser2k::parseShapeFlips(librevenge::RVNGInputStream *input
   }
 }
 
-void libmspub::MSPUBParser2k::parseShapeType(librevenge::RVNGInputStream *input,
-                                             unsigned seqNum, unsigned chunkOffset,
-                                             bool &isGroup, bool &isLine, bool &isImage, bool &isRectangle,
-                                             unsigned &flagsOffset)
+void MSPUBParser2k::parseShapeType(librevenge::RVNGInputStream *input,
+                                   unsigned seqNum, unsigned chunkOffset,
+                                   bool &isGroup, bool &isLine, bool &isImage, bool &isRectangle,
+                                   unsigned &flagsOffset)
 {
   input->seek(chunkOffset, librevenge::RVNG_SEEK_SET);
   unsigned short typeMarker = readU16(input);
@@ -671,28 +674,28 @@ void libmspub::MSPUBParser2k::parseShapeType(librevenge::RVNGInputStream *input,
   }
 }
 
-unsigned libmspub::MSPUBParser2k::getTextIdOffset() const
+unsigned MSPUBParser2k::getTextIdOffset() const
 {
   return 0x58;
 }
 
-unsigned short libmspub::MSPUBParser2k::getTextMarker() const
+unsigned short MSPUBParser2k::getTextMarker() const
 {
   return 0x0008;
 }
 
-unsigned libmspub::MSPUBParser2k::getFirstLineOffset() const
+unsigned MSPUBParser2k::getFirstLineOffset() const
 {
   return 0x2C;
 }
 
-unsigned libmspub::MSPUBParser2k::getSecondLineOffset() const
+unsigned MSPUBParser2k::getSecondLineOffset() const
 {
   return 0x35;
 }
 
-void libmspub::MSPUBParser2k::parseShapeLine(librevenge::RVNGInputStream *input, bool isRectangle, unsigned offset,
-                                             unsigned seqNum)
+void MSPUBParser2k::parseShapeLine(librevenge::RVNGInputStream *input, bool isRectangle, unsigned offset,
+                                   unsigned seqNum)
 {
   input->seek(offset + getFirstLineOffset(), librevenge::RVNG_SEEK_SET);
   unsigned short leftLineWidth = readU8(input);
@@ -729,7 +732,7 @@ void libmspub::MSPUBParser2k::parseShapeLine(librevenge::RVNGInputStream *input,
                                          translateLineWidth(leftLineWidth) * EMUS_IN_INCH / (4 * POINTS_IN_INCH), leftLineExists));
 }
 
-bool libmspub::MSPUBParser2k::parse()
+bool MSPUBParser2k::parse()
 {
   librevenge::RVNGInputStream *contents = m_input->getSubStreamByName("Contents");
   if (!contents)
@@ -758,7 +761,7 @@ bool libmspub::MSPUBParser2k::parse()
   return m_collector->go();
 }
 
-libmspub::PageType libmspub::MSPUBParser2k::getPageTypeBySeqNum(unsigned seqNum)
+PageType MSPUBParser2k::getPageTypeBySeqNum(unsigned seqNum)
 {
   switch (seqNum)
   {
@@ -775,4 +778,6 @@ libmspub::PageType libmspub::MSPUBParser2k::getPageTypeBySeqNum(unsigned seqNum)
   }
 }
 
+}
+
 /* vim:set shiftwidth=2 softtabstop=2 expandtab: */
diff --git a/src/lib/MSPUBParser97.cpp b/src/lib/MSPUBParser97.cpp
index f5190e3..3e4adce 100644
--- a/src/lib/MSPUBParser97.cpp
+++ b/src/lib/MSPUBParser97.cpp
@@ -12,23 +12,26 @@
 #include "libmspub_utils.h"
 #include "MSPUBTypes.h"
 
-libmspub::MSPUBParser97::MSPUBParser97(librevenge::RVNGInputStream *input, MSPUBCollector *collector)
+namespace libmspub
+{
+
+MSPUBParser97::MSPUBParser97(librevenge::RVNGInputStream *input, MSPUBCollector *collector)
   : MSPUBParser2k(input, collector), m_isBanner(false)
 {
   m_collector->useEncodingHeuristic();
 }
 
-unsigned short libmspub::MSPUBParser97::getTextMarker() const
+unsigned short MSPUBParser97::getTextMarker() const
 {
   return 0x0000;
 }
 
-unsigned libmspub::MSPUBParser97::getTextIdOffset() const
+unsigned MSPUBParser97::getTextIdOffset() const
 {
   return 0x46;
 }
 
-bool libmspub::MSPUBParser97::parse()
+bool MSPUBParser97::parse()
 {
   librevenge::RVNGInputStream *contents = m_input->getSubStreamByName("Contents");
   if (!contents)
@@ -45,7 +48,7 @@ bool libmspub::MSPUBParser97::parse()
   return m_collector->go();
 }
 
-bool libmspub::MSPUBParser97::parseDocument(librevenge::RVNGInputStream *input)
+bool MSPUBParser97::parseDocument(librevenge::RVNGInputStream *input)
 {
   if (!!m_documentChunkIndex)
   {
@@ -61,7 +64,7 @@ bool libmspub::MSPUBParser97::parseDocument(librevenge::RVNGInputStream *input)
   return false;
 }
 
-void libmspub::MSPUBParser97::parseContentsTextIfNecessary(librevenge::RVNGInputStream *input)
+void MSPUBParser97::parseContentsTextIfNecessary(librevenge::RVNGInputStream *input)
 {
   input->seek(0x12, librevenge::RVNG_SEEK_SET);
   input->seek(readU32(input), librevenge::RVNG_SEEK_SET);
@@ -140,7 +143,7 @@ void libmspub::MSPUBParser97::parseContentsTextIfNecessary(librevenge::RVNGInput
   }
 }
 
-std::vector<libmspub::MSPUBParser97::SpanInfo97> libmspub::MSPUBParser97::getSpansInfo(
+std::vector<MSPUBParser97::SpanInfo97> MSPUBParser97::getSpansInfo(
   librevenge::RVNGInputStream *input,
   unsigned prop1Index, unsigned prop2Index, unsigned /* prop3Index */,
   unsigned /* prop3End */)
@@ -188,7 +191,7 @@ std::vector<libmspub::MSPUBParser97::SpanInfo97> libmspub::MSPUBParser97::getSpa
   return ret;
 }
 
-libmspub::CharacterStyle libmspub::MSPUBParser97::readCharacterStyle(
+CharacterStyle MSPUBParser97::readCharacterStyle(
   librevenge::RVNGInputStream *input, unsigned length)
 {
   unsigned begin = input->tell();
@@ -230,7 +233,7 @@ libmspub::CharacterStyle libmspub::MSPUBParser97::readCharacterStyle(
                         fontIndex);
 }
 
-libmspub::MSPUBParser97::TextInfo97 libmspub::MSPUBParser97::getTextInfo(librevenge::RVNGInputStream *input, unsigned length)
+MSPUBParser97::TextInfo97 MSPUBParser97::getTextInfo(librevenge::RVNGInputStream *input, unsigned length)
 {
   std::vector<unsigned char> chars;
   chars.reserve(length);
@@ -254,7 +257,7 @@ libmspub::MSPUBParser97::TextInfo97 libmspub::MSPUBParser97::getTextInfo(libreve
   return TextInfo97(chars, paragraphEnds, shapeEnds);
 }
 
-int libmspub::MSPUBParser97::translateCoordinateIfNecessary(int coordinate) const
+int MSPUBParser97::translateCoordinateIfNecessary(int coordinate) const
 {
   if (m_isBanner)
   {
@@ -266,24 +269,26 @@ int libmspub::MSPUBParser97::translateCoordinateIfNecessary(int coordinate) cons
   }
 }
 
-unsigned libmspub::MSPUBParser97::getFirstLineOffset() const
+unsigned MSPUBParser97::getFirstLineOffset() const
 {
   return 0x22;
 }
 
-unsigned libmspub::MSPUBParser97::getSecondLineOffset() const
+unsigned MSPUBParser97::getSecondLineOffset() const
 {
   return 0x2D;
 }
 
-unsigned libmspub::MSPUBParser97::getShapeFillTypeOffset() const
+unsigned MSPUBParser97::getShapeFillTypeOffset() const
 {
   return 0x20;
 }
 
-unsigned libmspub::MSPUBParser97::getShapeFillColorOffset() const
+unsigned MSPUBParser97::getShapeFillColorOffset() const
 {
   return 0x18;
 }
 
+}
+
 /* vim:set shiftwidth=2 softtabstop=2 expandtab: */
diff --git a/src/lib/MSPUBStringVector.cpp b/src/lib/MSPUBStringVector.cpp
index ba53f0c..3f1bb75 100644
--- a/src/lib/MSPUBStringVector.cpp
+++ b/src/lib/MSPUBStringVector.cpp
@@ -20,24 +20,22 @@ public:
   std::vector<librevenge::RVNGString> m_strings;
 };
 
-} // namespace libmspub
-
-libmspub::MSPUBStringVector::MSPUBStringVector()
+MSPUBStringVector::MSPUBStringVector()
   : m_pImpl(new MSPUBStringVectorImpl())
 {
 }
 
-libmspub::MSPUBStringVector::MSPUBStringVector(const MSPUBStringVector &vec)
+MSPUBStringVector::MSPUBStringVector(const MSPUBStringVector &vec)
   : m_pImpl(new MSPUBStringVectorImpl(*(vec.m_pImpl)))
 {
 }
 
-libmspub::MSPUBStringVector::~MSPUBStringVector()
+MSPUBStringVector::~MSPUBStringVector()
 {
   delete m_pImpl;
 }
 
-libmspub::MSPUBStringVector &libmspub::MSPUBStringVector::operator=(const MSPUBStringVector &vec)
+MSPUBStringVector &MSPUBStringVector::operator=(const MSPUBStringVector &vec)
 {
   // Check for self-assignment
   if (this == &vec)
@@ -48,29 +46,31 @@ libmspub::MSPUBStringVector &libmspub::MSPUBStringVector::operator=(const MSPUBS
   return *this;
 }
 
-unsigned libmspub::MSPUBStringVector::size() const
+unsigned MSPUBStringVector::size() const
 {
   return (unsigned)(m_pImpl->m_strings.size());
 }
 
-bool libmspub::MSPUBStringVector::empty() const
+bool MSPUBStringVector::empty() const
 {
   return m_pImpl->m_strings.empty();
 }
 
-const librevenge::RVNGString &libmspub::MSPUBStringVector::operator[](unsigned idx) const
+const librevenge::RVNGString &MSPUBStringVector::operator[](unsigned idx) const
 {
   return m_pImpl->m_strings[idx];
 }
 
-void libmspub::MSPUBStringVector::append(const librevenge::RVNGString &str)
+void MSPUBStringVector::append(const librevenge::RVNGString &str)
 {
   m_pImpl->m_strings.push_back(str);
 }
 
-void libmspub::MSPUBStringVector::clear()
+void MSPUBStringVector::clear()
 {
   m_pImpl->m_strings.clear();
 }
 
+}
+
 /* vim:set shiftwidth=2 softtabstop=2 expandtab: */
diff --git a/src/lib/PolygonUtils.cpp b/src/lib/PolygonUtils.cpp
index 44a7f74..b6f40ab 100644
--- a/src/lib/PolygonUtils.cpp
+++ b/src/lib/PolygonUtils.cpp
@@ -23,7 +23,8 @@
 #define M_PI 3.14159265358979323846
 #endif
 
-using namespace libmspub;
+namespace libmspub
+{
 
 const Vertex LINE_VERTICES[] =
 {
@@ -5241,7 +5242,7 @@ const CustomShape CS_ACTION_BUTTON_MOVIE(
   21600, 21600,
   NULL, 0);
 
-const CustomShape *libmspub::getCustomShape(ShapeType type)
+const CustomShape *getCustomShape(ShapeType type)
 {
   switch (type)
   {
@@ -5679,7 +5680,7 @@ double getSpecialIfNecessary(boost::function<double(unsigned index)> calculator,
   return special ? calculator(val ^ 0x80000000) : val;
 }
 
-Coordinate libmspub::CustomShape::getTextRectangle(double x, double y, double width, double height, boost::function<double(unsigned index)> calculator) const
+Coordinate CustomShape::getTextRectangle(double x, double y, double width, double height, boost::function<double(unsigned index)> calculator) const
 {
   double scaleX = width * m_coordWidth;
   double scaleY = height * m_coordHeight;
@@ -5707,7 +5708,7 @@ struct LineInfo
   bool m_lineExists;
   LineInfo(librevenge::RVNGPropertyListVector vertices, Line current, std::vector<Color> palette) : m_vertices(vertices),
     m_width((double)(current.m_widthInEmu) / EMUS_IN_INCH),
-    m_color(libmspub::MSPUBCollector::getColorString(current.m_color.getFinalColor(palette))),
+    m_color(MSPUBCollector::getColorString(current.m_color.getFinalColor(palette))),
     m_lineExists(current.m_lineExists) { }
   void output(librevenge::RVNGDrawingInterface *painter, librevenge::RVNGPropertyList &graphicsProps)
   {
@@ -5879,7 +5880,7 @@ void getRayEllipseIntersection(double initX, double initY, double rx, double ry,
   yOut += cy;
 }
 
-librevenge::RVNGPropertyList libmspub::calcClipPath(const std::vector<libmspub::Vertex> &verts, double x, double y, double height, double width, VectorTransformation2D transform, boost::shared_ptr<const CustomShape> shape)
+librevenge::RVNGPropertyList calcClipPath(const std::vector<Vertex> &verts, double x, double y, double height, double width, VectorTransformation2D transform, boost::shared_ptr<const CustomShape> shape)
 {
   librevenge::RVNGPropertyList vertices;
   Vector2D center(x + width / 2, y + height / 2);
@@ -5904,7 +5905,7 @@ librevenge::RVNGPropertyList libmspub::calcClipPath(const std::vector<libmspub::
   return vertices;
 }
 
-void libmspub::writeCustomShape(ShapeType shapeType, librevenge::RVNGPropertyList &graphicsProps, librevenge::RVNGDrawingInterface *painter, double x, double y, double height, double width, bool closeEverything, VectorTransformation2D transform, std::vector<Line> lines, boost::function<double(unsigned index)> calculator, const std::vector<Color> &palette, boost::shared_ptr<const CustomShape> shape)
+void writeCustomShape(ShapeType shapeType, librevenge::RVNGPropertyList &graphicsProps, librevenge::RVNGDrawingInterface *painter, double x, double y, double height, double width, bool closeEverything, VectorTransformation2D transform, std::vector<Line> lines, boost::function<double(unsigned index)> calculator, const std::vector<Color> &palette, boost::shared_ptr<const CustomShape> shape)
 {
   MSPUB_DEBUG_MSG(("***STARTING CUSTOM SHAPE***\n"));
   if (!shape)
@@ -5947,7 +5948,7 @@ void libmspub::writeCustomShape(ShapeType shapeType, librevenge::RVNGPropertyLis
           graphicsProps.insert("draw:stroke", "none");
         }
         graphicsProps.insert("svg:stroke-width", (double)(first.m_widthInEmu) / EMUS_IN_INCH);
-        graphicsProps.insert("svg:stroke-color", libmspub::MSPUBCollector::getColorString(first.m_color.getFinalColor(palette)));
+        graphicsProps.insert("svg:stroke-color", MSPUBCollector::getColorString(first.m_color.getFinalColor(palette)));
         painter->setStyle(graphicsProps);
       }
     }
@@ -5981,7 +5982,7 @@ void libmspub::writeCustomShape(ShapeType shapeType, librevenge::RVNGPropertyLis
         graphicsProps.insert("draw:stroke", "none");
       }
       graphicsProps.insert("svg:stroke-width", (double)(first.m_widthInEmu) / EMUS_IN_INCH);
-      graphicsProps.insert("svg:stroke-color", libmspub::MSPUBCollector::getColorString(first.m_color.getFinalColor(palette)));
+      graphicsProps.insert("svg:stroke-color", MSPUBCollector::getColorString(first.m_color.getFinalColor(palette)));
       painter->setStyle(graphicsProps);
     }
     unsigned vertexIndex = 0;
@@ -6371,13 +6372,13 @@ void libmspub::writeCustomShape(ShapeType shapeType, librevenge::RVNGPropertyLis
   }
 }
 
-bool libmspub::isShapeTypeRectangle(ShapeType type)
+bool isShapeTypeRectangle(ShapeType type)
 {
   return type == RECTANGLE || type == TEXT_BOX;
 }
 
 
-boost::shared_ptr<const libmspub::CustomShape> libmspub::getFromDynamicCustomShape(const libmspub::DynamicCustomShape &dcs)
+boost::shared_ptr<const CustomShape> getFromDynamicCustomShape(const DynamicCustomShape &dcs)
 {
   return boost::shared_ptr<const CustomShape>(new CustomShape(
                                                 dcs.m_vertices.empty() ? NULL : &dcs.m_vertices[0],
@@ -6398,4 +6399,6 @@ boost::shared_ptr<const libmspub::CustomShape> libmspub::getFromDynamicCustomSha
                                               ));
 }
 
+}
+
 /* vim:set shiftwidth=2 softtabstop=2 expandtab: */
diff --git a/src/lib/Shadow.cpp b/src/lib/Shadow.cpp
index cdfcb04..b42565b 100644
--- a/src/lib/Shadow.cpp
+++ b/src/lib/Shadow.cpp
@@ -9,8 +9,14 @@
 
 #include "Shadow.h"
 
-bool libmspub::needsEmulation(const Shadow &shadow)
+namespace libmspub
+{
+
+bool needsEmulation(const Shadow &shadow)
 {
   return !(shadow.m_type == OFFSET);
 }
+
+}
+
 /* vim:set shiftwidth=2 softtabstop=2 expandtab: */
diff --git a/src/lib/ShapeGroupElement.cpp b/src/lib/ShapeGroupElement.cpp
index 12ae179..c828eb7 100644
--- a/src/lib/ShapeGroupElement.cpp
+++ b/src/lib/ShapeGroupElement.cpp
@@ -9,7 +9,10 @@
 
 #include "ShapeGroupElement.h"
 
-libmspub::ShapeGroupElement::ShapeGroupElement(ShapeGroupElement *parent) : m_shapeInfo(), m_parent(parent), m_children(), m_seqNum(0), m_transform()
+namespace libmspub
+{
+
+ShapeGroupElement::ShapeGroupElement(ShapeGroupElement *parent) : m_shapeInfo(), m_parent(parent), m_children(), m_seqNum(0), m_transform()
 {
   if (m_parent)
   {
@@ -17,7 +20,7 @@ libmspub::ShapeGroupElement::ShapeGroupElement(ShapeGroupElement *parent) : m_sh
   }
 }
 
-libmspub::ShapeGroupElement::~ShapeGroupElement()
+ShapeGroupElement::~ShapeGroupElement()
 {
   for (unsigned i = 0; i < m_children.size(); ++i)
   {
@@ -25,7 +28,7 @@ libmspub::ShapeGroupElement::~ShapeGroupElement()
   }
 }
 
-libmspub::ShapeGroupElement::ShapeGroupElement(ShapeGroupElement *parent, unsigned seqNum) : m_shapeInfo(), m_parent(parent), m_children(), m_seqNum(seqNum), m_transform()
+ShapeGroupElement::ShapeGroupElement(ShapeGroupElement *parent, unsigned seqNum) : m_shapeInfo(), m_parent(parent), m_children(), m_seqNum(seqNum), m_transform()
 {
   if (m_parent)
   {
@@ -33,17 +36,17 @@ libmspub::ShapeGroupElement::ShapeGroupElement(ShapeGroupElement *parent, unsign
   }
 }
 
-void libmspub::ShapeGroupElement::setShapeInfo(const ShapeInfo &shapeInfo)
+void ShapeGroupElement::setShapeInfo(const ShapeInfo &shapeInfo)
 {
   m_shapeInfo = shapeInfo;
 }
 
-void libmspub::ShapeGroupElement::setTransform(const VectorTransformation2D &transform)
+void ShapeGroupElement::setTransform(const VectorTransformation2D &transform)
 {
   m_transform = transform;
 }
 
-void libmspub::ShapeGroupElement::setup(boost::function<void(ShapeGroupElement &self)> visitor)
+void ShapeGroupElement::setup(boost::function<void(ShapeGroupElement &self)> visitor)
 {
   visitor(*this);
   for (unsigned i = 0; i < m_children.size(); ++i)
@@ -52,10 +55,10 @@ void libmspub::ShapeGroupElement::setup(boost::function<void(ShapeGroupElement &
   }
 }
 
-void libmspub::ShapeGroupElement::visit(boost::function<
-                                        boost::function<void(void)>
-                                        (const libmspub::ShapeInfo &info, const libmspub::Coordinate &relativeTo, const libmspub::VectorTransformation2D &foldedTransform, bool isGroup, const libmspub::VectorTransformation2D &thisTransform)
-                                        > visitor, const Coordinate &relativeTo, const VectorTransformation2D &parentFoldedTransform) const
+void ShapeGroupElement::visit(boost::function<
+                              boost::function<void(void)>
+                              (const ShapeInfo &info, const Coordinate &relativeTo, const VectorTransformation2D &foldedTransform, bool isGroup, const VectorTransformation2D &thisTransform)
+                              > visitor, const Coordinate &relativeTo, const VectorTransformation2D &parentFoldedTransform) const
 {
   const ShapeInfo &info = m_shapeInfo.get_value_or(ShapeInfo());
   Coordinate coord = info.m_coordinates.get_value_or(Coordinate());
@@ -75,39 +78,41 @@ void libmspub::ShapeGroupElement::visit(boost::function<
   afterOp();
 }
 
-void libmspub::ShapeGroupElement::visit(boost::function<
-                                        boost::function<void(void)>
-                                        (const libmspub::ShapeInfo &info, const libmspub::Coordinate &relativeTo, const libmspub::VectorTransformation2D &foldedTransform, bool isGroup, const libmspub::VectorTransformation2D &thisTransform)
-                                        > visitor) const
+void ShapeGroupElement::visit(boost::function<
+                              boost::function<void(void)>
+                              (const ShapeInfo &info, const Coordinate &relativeTo, const VectorTransformation2D &foldedTransform, bool isGroup, const VectorTransformation2D &thisTransform)
+                              > visitor) const
 {
   Coordinate origin;
   VectorTransformation2D identity;
   visit(visitor, origin, identity);
 }
 
-bool libmspub::ShapeGroupElement::isGroup() const
+bool ShapeGroupElement::isGroup() const
 {
   return !m_children.empty();
 }
 
-libmspub::ShapeGroupElement *libmspub::ShapeGroupElement::getParent()
+ShapeGroupElement *ShapeGroupElement::getParent()
 {
   return m_parent;
 }
 
-const libmspub::ShapeGroupElement *libmspub::ShapeGroupElement::getParent() const
+const ShapeGroupElement *ShapeGroupElement::getParent() const
 {
   return m_parent;
 }
 
-void libmspub::ShapeGroupElement::setSeqNum(unsigned seqNum)
+void ShapeGroupElement::setSeqNum(unsigned seqNum)
 {
   m_seqNum = seqNum;
 }
 
-unsigned libmspub::ShapeGroupElement::getSeqNum() const
+unsigned ShapeGroupElement::getSeqNum() const
 {
   return m_seqNum;
 }
 
+}
+
 /* vim:set shiftwidth=2 softtabstop=2 expandtab: */
diff --git a/src/lib/VectorTransformation2D.cpp b/src/lib/VectorTransformation2D.cpp
index e599473..1b80e3a 100644
--- a/src/lib/VectorTransformation2D.cpp
+++ b/src/lib/VectorTransformation2D.cpp
@@ -12,12 +12,15 @@
 #include "VectorTransformation2D.h"
 #include <math.h>
 
-libmspub::VectorTransformation2D::VectorTransformation2D() : m_m11(1), m_m12(0), m_m21(0), m_m22(1), m_x(0), m_y(0)
+namespace libmspub
+{
+
+VectorTransformation2D::VectorTransformation2D() : m_m11(1), m_m12(0), m_m21(0), m_m22(1), m_x(0), m_y(0)
 {
 }
 
 //We choose by convention to make function composition LEFT-multiplication, rather than right.
-libmspub::VectorTransformation2D libmspub::operator*(const VectorTransformation2D &l, const VectorTransformation2D &r)
+VectorTransformation2D operator*(const VectorTransformation2D &l, const VectorTransformation2D &r)
 {
   VectorTransformation2D ret;
   ret.m_m11 = l.m_m11 * r.m_m11 + l.m_m12 * r.m_m21;
@@ -29,7 +32,7 @@ libmspub::VectorTransformation2D libmspub::operator*(const VectorTransformation2
   return ret;
 }
 
-libmspub::VectorTransformation2D libmspub::VectorTransformation2D::fromFlips(bool flipH, bool flipV)
+VectorTransformation2D VectorTransformation2D::fromFlips(bool flipH, bool flipV)
 {
   VectorTransformation2D ret;
   ret.m_m21 = ret.m_m12 = 0;
@@ -38,7 +41,7 @@ libmspub::VectorTransformation2D libmspub::VectorTransformation2D::fromFlips(boo
   return ret;
 }
 
-libmspub::VectorTransformation2D libmspub::VectorTransformation2D::fromTranslate(double x, double y)
+VectorTransformation2D VectorTransformation2D::fromTranslate(double x, double y)
 {
   VectorTransformation2D ret;
   ret.m_m11 = ret.m_m22 = 1;
@@ -48,7 +51,7 @@ libmspub::VectorTransformation2D libmspub::VectorTransformation2D::fromTranslate
   return ret;
 }
 
-libmspub::VectorTransformation2D libmspub::VectorTransformation2D::fromCounterRadians(double theta)
+VectorTransformation2D VectorTransformation2D::fromCounterRadians(double theta)
 {
   VectorTransformation2D ret;
   ret.m_m11 = cos(theta);
@@ -58,33 +61,33 @@ libmspub::VectorTransformation2D libmspub::VectorTransformation2D::fromCounterRa
   return ret;
 }
 
-libmspub::Vector2D libmspub::VectorTransformation2D::transform(Vector2D v) const
+Vector2D VectorTransformation2D::transform(Vector2D v) const
 {
   double x = m_m11 * v.m_x + m_m12 * v.m_y + m_x;
   double y = m_m21 * v.m_x + m_m22 * v.m_y + m_y;
   return Vector2D(x, y);
 }
 
-libmspub::Vector2D libmspub::VectorTransformation2D::transformWithOrigin(Vector2D v, Vector2D origin) const
+Vector2D VectorTransformation2D::transformWithOrigin(Vector2D v, Vector2D origin) const
 {
   return transform(v - origin) + origin;
 }
 
-libmspub::Vector2D libmspub::operator+(const Vector2D &l, const Vector2D &r)
+Vector2D operator+(const Vector2D &l, const Vector2D &r)
 {
   double x = l.m_x + r.m_x;
   double y = l.m_y + r.m_y;
   return Vector2D(x, y);
 }
 
-libmspub::Vector2D libmspub::operator-(const Vector2D &l, const Vector2D &r)
+Vector2D operator-(const Vector2D &l, const Vector2D &r)
 {
   double x = l.m_x - r.m_x;
   double y = l.m_y - r.m_y;
   return Vector2D(x, y);
 }
 
-double libmspub::VectorTransformation2D::getRotation() const
+double VectorTransformation2D::getRotation() const
 {
   if (fabs(getHorizontalScaling()) > 0.0001)
   {
@@ -97,19 +100,22 @@ double libmspub::VectorTransformation2D::getRotation() const
   return 0;
 }
 
-double libmspub::VectorTransformation2D::getHorizontalScaling() const
+double VectorTransformation2D::getHorizontalScaling() const
 {
   return m_m11 * m_m11 + m_m21 * m_m21;
 }
 
-double libmspub::VectorTransformation2D::getVerticalScaling() const
+double VectorTransformation2D::getVerticalScaling() const
 {
   return m_m12 * m_m12 + m_m22 * m_m22;
 }
 
-bool libmspub::VectorTransformation2D::orientationReversing() const
+bool VectorTransformation2D::orientationReversing() const
 {
   // Is the determinant negative?
   return m_m11 * m_m22 < m_m12 * m_m21;
 }
+
+}
+
 /* vim:set shiftwidth=2 softtabstop=2 expandtab: */
diff --git a/src/lib/libmspub_utils.cpp b/src/lib/libmspub_utils.cpp
index 3628e14..dd98762 100644
--- a/src/lib/libmspub_utils.cpp
+++ b/src/lib/libmspub_utils.cpp
@@ -23,8 +23,11 @@
 
 #define ZLIB_CHUNK 16384
 
+namespace libmspub
+{
+
 using std::strcmp;
-const char *libmspub::windowsCharsetNameByOriginalCharset(const char *name)
+const char *windowsCharsetNameByOriginalCharset(const char *name)
 {
   if (strcmp(name, "Shift_JIS") == 0)
   {
@@ -57,7 +60,7 @@ const char *libmspub::windowsCharsetNameByOriginalCharset(const char *name)
   return NULL;
 }
 
-const char *libmspub::mimeByImgType(ImgType type)
+const char *mimeByImgType(ImgType type)
 {
   switch (type)
   {
@@ -81,7 +84,7 @@ const char *libmspub::mimeByImgType(ImgType type)
   }
 }
 
-void libmspub::rotateCounter(double &x, double &y, double centerX, double centerY, short rotation)
+void rotateCounter(double &x, double &y, double centerX, double centerY, short rotation)
 {
   double vecX = x - centerX;
   double vecY = centerY - y;
@@ -93,7 +96,7 @@ void libmspub::rotateCounter(double &x, double &y, double centerX, double center
   y = centerY - newVecY;
 }
 
-double libmspub::doubleModulo(double x, double y)
+double doubleModulo(double x, double y)
 {
   if (y <= 0) // y <= 0 doesn't make sense
   {
@@ -110,19 +113,19 @@ double libmspub::doubleModulo(double x, double y)
   return x;
 }
 
-double libmspub::toFixedPoint(int fp)
+double toFixedPoint(int fp)
 {
   unsigned short fractionalPart = ((unsigned short) fp) & 0xFFFF;
   short integralPart = fp >> 16;
   return integralPart + fractionalPart / 65536.;
 }
 
-double libmspub::readFixedPoint(librevenge::RVNGInputStream *input)
+double readFixedPoint(librevenge::RVNGInputStream *input)
 {
   return toFixedPoint(readS32(input));
 }
 
-void libmspub::flipIfNecessary(double &x, double &y, double centerX, double centerY, bool flipVertical, bool flipHorizontal)
+void flipIfNecessary(double &x, double &y, double centerX, double centerY, bool flipVertical, bool flipHorizontal)
 {
   double vecX = x - centerX;
   double vecY = centerY - y;
@@ -136,7 +139,7 @@ void libmspub::flipIfNecessary(double &x, double &y, double centerX, double cent
   }
 }
 
-unsigned libmspub::correctModulo(int x, unsigned n) // returns the canonical representation of x in Z/nZ
+unsigned correctModulo(int x, unsigned n) // returns the canonical representation of x in Z/nZ
 //difference with C++ % operator is that this never returns negative values.
 {
   if (x < 0)
@@ -152,7 +155,7 @@ unsigned libmspub::correctModulo(int x, unsigned n) // returns the canonical rep
   return x % n;
 }
 
-librevenge::RVNGBinaryData libmspub::inflateData(librevenge::RVNGBinaryData deflated)
+librevenge::RVNGBinaryData inflateData(librevenge::RVNGBinaryData deflated)
 {
   librevenge::RVNGBinaryData inflated;
   unsigned char out[ZLIB_CHUNK];
@@ -251,7 +254,7 @@ static void _appendUCS4(librevenge::RVNGString &text, unsigned ucs4Character)
 
 #define MSPUB_NUM_ELEMENTS(array) sizeof(array)/sizeof(array[0])
 
-uint8_t libmspub::readU8(librevenge::RVNGInputStream *input)
+uint8_t readU8(librevenge::RVNGInputStream *input)
 {
   if (!input || input->isEnd())
   {
@@ -270,14 +273,14 @@ uint8_t libmspub::readU8(librevenge::RVNGInputStream *input)
   throw EndOfStreamException();
 }
 
-uint16_t libmspub::readU16(librevenge::RVNGInputStream *input)
+uint16_t readU16(librevenge::RVNGInputStream *input)
 {
   uint16_t p0 = (uint16_t)readU8(input);
   uint16_t p1 = (uint16_t)readU8(input);
   return (uint16_t)(p0|(p1<<8));
 }
 
-uint32_t libmspub::readU32(librevenge::RVNGInputStream *input)
+uint32_t readU32(librevenge::RVNGInputStream *input)
 {
   uint32_t p0 = (uint32_t)readU8(input);
   uint32_t p1 = (uint32_t)readU8(input);
@@ -286,22 +289,22 @@ uint32_t libmspub::readU32(librevenge::RVNGInputStream *input)
   return (uint32_t)(p0|(p1<<8)|(p2<<16)|(p3<<24));
 }
 
-int8_t libmspub::readS8(librevenge::RVNGInputStream *input)
+int8_t readS8(librevenge::RVNGInputStream *input)
 {
   return (int8_t)readU8(input);
 }
 
-int16_t libmspub::readS16(librevenge::RVNGInputStream *input)
+int16_t readS16(librevenge::RVNGInputStream *input)
 {
   return (int16_t)readU16(input);
 }
 
-int32_t libmspub::readS32(librevenge::RVNGInputStream *input)
+int32_t readS32(librevenge::RVNGInputStream *input)
 {
   return (int32_t)readU32(input);
 }
 
-uint64_t libmspub::readU64(librevenge::RVNGInputStream *input)
+uint64_t readU64(librevenge::RVNGInputStream *input)
 {
   uint64_t p0 = (uint64_t)readU8(input);
   uint64_t p1 = (uint64_t)readU8(input);
@@ -314,7 +317,7 @@ uint64_t libmspub::readU64(librevenge::RVNGInputStream *input)
   return (uint64_t)(p0|(p1<<8)|(p2<<16)|(p3<<24)|(p4<<32)|(p5<<40)|(p6<<48)|(p7<<56));
 }
 
-void libmspub::readNBytes(librevenge::RVNGInputStream *input, unsigned long length, std::vector<unsigned char> &out)
+void readNBytes(librevenge::RVNGInputStream *input, unsigned long length, std::vector<unsigned char> &out)
 {
   if (length == 0)
   {
@@ -337,8 +340,8 @@ void libmspub::readNBytes(librevenge::RVNGInputStream *input, unsigned long leng
 #define SURROGATE_VALUE(h,l) (((h) - 0xd800) * 0x400 + (l) - 0xdc00 + 0x10000)
 
 
-void libmspub::appendCharacters(librevenge::RVNGString &text, const std::vector<unsigned char> characters,
-                                const char *encoding)
+void appendCharacters(librevenge::RVNGString &text, const std::vector<unsigned char> characters,
+                      const char *encoding)
 {
   if (characters.empty())
   {
@@ -370,7 +373,7 @@ void libmspub::appendCharacters(librevenge::RVNGString &text, const std::vector<
   }
 }
 
-bool libmspub::stillReading(librevenge::RVNGInputStream *input, unsigned long until)
+bool stillReading(librevenge::RVNGInputStream *input, unsigned long until)
 {
   if (input->isEnd())
     return false;
@@ -381,4 +384,6 @@ bool libmspub::stillReading(librevenge::RVNGInputStream *input, unsigned long un
   return true;
 }
 
+}
+
 /* vim:set shiftwidth=2 softtabstop=2 expandtab: */