#i65904# Initial revision

27 files changed, 6078 insertions, 0 deletions

diff --git a/basebmp/inc/basebmp/accessor.hxx b/basebmp/inc/basebmp/accessor.hxx
new file mode 100644
index 000000000000..2718ad1bf5e9
--- /dev/null
+++ b/basebmp/inc/basebmp/accessor.hxx
@@ -0,0 +1,74 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: accessor.hxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: thb $ $Date: 2006-05-31 09:49:41 $
+ *
+ *  The Contents of this file are made available subject to
+ *  the terms of GNU Lesser General Public License Version 2.1.
+ *
+ *
+ *    GNU Lesser General Public License Version 2.1
+ *    =============================================
+ *    Copyright 2005 by Sun Microsystems, Inc.
+ *    901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *    This library is free software; you can redistribute it and/or
+ *    modify it under the terms of the GNU Lesser General Public
+ *    License version 2.1, as published by the Free Software Foundation.
+ *
+ *    This library is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *    Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with this library; if not, write to the Free Software
+ *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *    MA  02111-1307  USA
+ *
+ ************************************************************************/
+
+#ifndef INCLUDED_BASEBMP_ACCESSOR_HXX
+#define INCLUDED_BASEBMP_ACCESSOR_HXX
+
+namespace basebmp
+{
+
+template<typename ValueType> class StandardAccessor
+{
+public:
+    typedef ValueType value_type;
+    typedef ValueType data_type;
+
+    template< class Iterator >
+    value_type operator()(Iterator const& i) const { return i.get(); }
+    value_type operator()(value_type const* i) const { return *i; }
+
+    template< class Iterator, class Difference >
+    value_type operator()(Iterator const& i, Difference const& diff) const
+    {
+        return i.get(diff);
+    }
+
+    template< typename V, class Iterator >
+    void set(V const& value, Iterator const& i) const
+    {
+        i.set( vigra::detail::RequiresExplicitCast<value_type>::cast(value) );
+    }
+
+    template< typename V, class Iterator, class Difference >
+    void set(V const& value, Iterator const& i, Difference const& diff) const
+    {
+        i.set( vigra::detail::RequiresExplicitCast<value_type>::cast(value),
+               diff );
+    }
+};
+
+} // namespace basebmp
+
+#endif /* INCLUDED_BASEBMP_ACCESSOR_HXX */
diff --git a/basebmp/inc/basebmp/accessoradapters.hxx b/basebmp/inc/basebmp/accessoradapters.hxx
new file mode 100644
index 000000000000..63c7e2ad25bc
--- /dev/null
+++ b/basebmp/inc/basebmp/accessoradapters.hxx
@@ -0,0 +1,271 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: accessoradapters.hxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: thb $ $Date: 2006-05-31 09:49:41 $
+ *
+ *  The Contents of this file are made available subject to
+ *  the terms of GNU Lesser General Public License Version 2.1.
+ *
+ *
+ *    GNU Lesser General Public License Version 2.1
+ *    =============================================
+ *    Copyright 2005 by Sun Microsystems, Inc.
+ *    901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *    This library is free software; you can redistribute it and/or
+ *    modify it under the terms of the GNU Lesser General Public
+ *    License version 2.1, as published by the Free Software Foundation.
+ *
+ *    This library is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *    Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with this library; if not, write to the Free Software
+ *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *    MA  02111-1307  USA
+ *
+ ************************************************************************/
+
+#ifndef INCLUDED_BASEBMP_ACCESSORADAPTERS_HXX
+#define INCLUDED_BASEBMP_ACCESSORADAPTERS_HXX
+
+#include "metafunctions.hxx"
+#include "packedpixeliterator.hxx"
+#include "paletteimageaccessor.hxx"
+
+namespace basebmp
+{
+
+/** Interpose given accessor's set methods with a binary function,
+    taking both old and new value.
+ */
+template< class WrappedAccessor, typename Functor > class BinarySetterFunctionAccessorAdapter :
+        public WrappedAccessor
+{
+private:
+    Functor maFunctor;
+
+public:
+    BinarySetterFunctionAccessorAdapter() :
+        WrappedAccessor(),
+        maFunctor()
+    {}
+
+    explicit BinarySetterFunctionAccessorAdapter( WrappedAccessor accessor ) :
+        WrappedAccessor( accessor ),
+        maFunctor()
+    {}
+
+    BinarySetterFunctionAccessorAdapter( WrappedAccessor accessor,
+                                         Functor         functor ) :
+        WrappedAccessor( accessor ),
+        maFunctor( functor )
+    {}
+
+    template< typename V, class Iterator >
+    void set(V const& value, Iterator const& i) const
+    {
+        WrappedAccessor::set(
+            maFunctor(WrappedAccessor::operator()(i),
+                      value),
+            i );
+    }
+
+    template< typename V, class Iterator, class Difference >
+    void set(V const& value, Iterator const& i, Difference const& diff) const
+    {
+        WrappedAccessor::set(
+            maFunctor(WrappedAccessor::operator()(i,diff),
+                      value),
+            i,
+            diff );
+    }
+};
+
+/** Read from two input iterators, pipe that through given functor, and write result
+    to the first iterator
+
+    Note: iterator type is fixed, to facilitate type-safe mask
+    optimizations (see below)
+ */
+template< class WrappedAccessor1,
+          class WrappedAccessor2,
+          class Iterator1,
+          class Iterator2,
+          typename Functor > class BinaryInputAccessorAdapter
+{
+private:
+    WrappedAccessor1 ma1stAccessor;
+    WrappedAccessor2 ma2ndAccessor;
+    Functor          maFunctor;
+
+public:
+    typedef typename WrappedAccessor1::value_type value_type;
+
+    BinaryInputAccessorAdapter() :
+        ma1stAccessor(),
+        ma2ndAccessor(),
+        maFunctor()
+    {}
+
+    explicit BinaryInputAccessorAdapter( WrappedAccessor1 accessor1 ) :
+        ma1stAccessor( accessor1 ),
+        ma2ndAccessor(),
+        maFunctor()
+    {}
+
+    BinaryInputAccessorAdapter( WrappedAccessor1 accessor1,
+                                WrappedAccessor2 accessor2 ) :
+        ma1stAccessor( accessor1 ),
+        ma2ndAccessor( accessor2 ),
+        maFunctor()
+    {}
+
+    BinaryInputAccessorAdapter( WrappedAccessor1 accessor1,
+                                WrappedAccessor2 accessor2,
+                                Functor          func ) :
+        ma1stAccessor( accessor1 ),
+        ma2ndAccessor( accessor2 ),
+        maFunctor( func )
+    {}
+
+    value_type operator()(Iterator1 const& i, Iterator2 const& j) const
+    {
+        return maFunctor(ma1stAccessor(i),
+                         ma2ndAccessor(j));
+    }
+    template< class Difference >
+    value_type operator()(Iterator1 const& i, Iterator2 const& j, Difference const& diff) const
+    {
+        return maFunctor(ma1stAccessor(i,diff),
+                         ma2ndAccessor(j,diff));
+    }
+
+    template< typename V >
+    void set(V const& value, Iterator1 const& i, Iterator2 const& j) const
+    {
+        ma1stAccessor.set(
+            maFunctor(ma1stAccessor(i),
+                      ma2ndAccessor(j)),
+            i );
+    }
+
+    template< typename V, class Difference >
+    void set(V const& value, Iterator1 const& i, Iterator2 const& j, Difference const& diff) const
+    {
+        ma1stAccessor.set(
+            maFunctor(ma1stAccessor(i,diff),
+                      ma2ndAccessor(j,diff)),
+            i,
+            diff );
+    }
+};
+
+// Some common accessor wrappers
+// ------------------------------------------------------------
+
+// XOR
+template< typename T > struct XorFunctor
+{
+    T operator()( T v1, T v2 ) const { return v1 ^ v2; }
+};
+template< class WrappedAccessor > struct xorAccessor
+{
+    typedef BinarySetterFunctionAccessorAdapter< WrappedAccessor,
+                                                 XorFunctor< typename WrappedAccessor::value_type > >
+        type;
+};
+
+// Mask
+template< typename T > struct MaskFunctor
+{
+    /** Mask v with state of m
+
+        @return v, if m != 0, and vigra::NumericTraits<T>::zero
+        otherwise.
+     */
+    T operator()( T v, T m ) const
+    {
+        // TODO(Q3): use traits to get unsigned type for T (if
+        // not already)
+
+        // mask will be 0, iff m == 0, and 1 otherwise
+        const T mask( static_cast<unsigned int>(m | -m) >> (sizeof(unsigned int)*8 - 1) );
+        return mask*v;
+    }
+};
+// Faster mask (assuming mask accessor output is already either 0 or 1)
+template< typename T > struct FastMaskFunctor
+{
+    T operator()( T v, T m ) const
+    {
+        return m*v;
+    }
+};
+// Chosen function crucially depends on iterator - we can choose the
+// faster direkt masking for 1bpp packed pixel iterators
+template< class WrappedAccessor,
+          class MaskAccessor,
+          class Iterator,
+          class MaskIterator > struct maskedAccessor
+{
+    typedef BinaryInputAccessorAdapter< WrappedAccessor,
+                                        MaskAccessor,
+                                        Iterator,
+                                        MaskIterator,
+                                        MaskFunctor< typename WrappedAccessor::value_type > >
+        type;
+};
+// partial specialization, to use fast 1bpp mask function for
+// corresponding iterator type
+template< class WrappedAccessor,
+          class MaskAccessor,
+          class Iterator > struct maskedAccessor< WrappedAccessor,
+                                                  MaskAccessor,
+                                                  Iterator,
+                                                  PackedPixelIterator< typename MaskAccessor::data_type,
+                                                                       typename MaskAccessor::value_type,
+                                                                       1,
+                                                                       true > >
+{
+    typedef BinaryInputAccessorAdapter< WrappedAccessor,
+                                        MaskAccessor,
+                                        Iterator,
+                                        PackedPixelIterator< typename MaskAccessor::data_type,
+                                                             typename MaskAccessor::value_type,
+                                                             1,
+                                                             true >,
+                                        FastMaskFunctor< typename WrappedAccessor::value_type > >
+        type;
+};
+template< class WrappedAccessor,
+          class MaskAccessor,
+          class Iterator > struct maskedAccessor< WrappedAccessor,
+                                                  MaskAccessor,
+                                                  Iterator,
+                                                  PackedPixelIterator< typename MaskAccessor::data_type,
+                                                                       typename MaskAccessor::value_type,
+                                                                       1,
+                                                                       false > >
+{
+    typedef BinaryInputAccessorAdapter< WrappedAccessor,
+                                        MaskAccessor,
+                                        Iterator,
+                                        PackedPixelIterator< typename MaskAccessor::data_type,
+                                                             typename MaskAccessor::value_type,
+                                                             1,
+                                                             false >,
+                                        FastMaskFunctor< typename WrappedAccessor::value_type > >
+        type;
+};
+
+} // namespace basebmp
+
+#endif /* INCLUDED_BASEBMP_ACCESSORADAPTERS_HXX */
diff --git a/basebmp/inc/basebmp/bitmapdevice.hxx b/basebmp/inc/basebmp/bitmapdevice.hxx
new file mode 100644
index 000000000000..3fd6401a6be6
--- /dev/null
+++ b/basebmp/inc/basebmp/bitmapdevice.hxx
@@ -0,0 +1,381 @@
+/*************************************************************************
+ *
+ *  $RCSfile: bitmapdevice.hxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: thb $ $Date: 2006-05-31 09:49:41 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *  MA  02111-1307  USA
+ *
+ ************************************************************************/
+
+#ifndef INCLUDED_BASEBMP_BITMAPDEVICE_HXX
+#define INCLUDED_BASEBMP_BITMAPDEVICE_HXX
+
+#ifndef _SAL_TYPES_H_
+#include <sal/types.h>
+#endif
+#ifndef INCLUDED_BASEBMP_DRAWMODES_HXX
+#include "drawmodes.hxx"
+#endif
+
+#include <boost/scoped_ptr.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/noncopyable.hpp>
+
+
+/* What to do first:
+
+   1,8,24 bpp, with blt, fill/drawPolygon, drawLine & get/setPixel
+
+   Then:
+
+   all other formats, top down vs. bottom up
+
+   Last:
+
+   Modulation, clip
+
+ */
+
+namespace basegfx
+{
+    class B2IPoint;
+    class B2DPoint;
+    class B2IVector;
+    class B2IRange;
+    class B2DPolygon;
+    class B2DPolyPolygon;
+}
+
+namespace basebmp
+{
+
+// Temporary. Use like the tools color object
+class Color;
+typedef boost::shared_ptr< class BitmapDevice > BitmapDeviceSharedPtr;
+typedef boost::shared_ptr< sal_uInt8 >          RawMemorySharedPtr;
+
+struct ImplBitmapDevice;
+
+/** Definition of BitmapDevice interface
+
+    Use createBitmapDevice() factory method to create one instance.
+
+    Implementation note: the clip mask and bitmap parameter instances
+    of BitmapDevice that are passed to individual BitmapDevice
+    instances work best with 1 bit MSB masks for the clip and a format
+    matching that of the target BitmapDevice for the other
+    parameters. Everything else is accepted, but potentially slow.
+ */
+class BitmapDevice : private boost::noncopyable
+{
+public:
+    /** Query size of device in pixel
+     */
+    basegfx::B2IVector getSize() const;
+
+    /** Query whether buffer starts with 0th scanline
+
+        @return true, if the buffer memory starts with the 0th
+        scanline, and false if it starts with the last
+     */
+    bool isTopDown() const;
+
+    /** Query type of scanline memory format
+     */
+    sal_Int32 getScanlineFormat() const;
+
+    /** Query byte offset to get from scanline n to scanline n+1
+
+        @return the scanline stride in bytes. In the case of
+        bottom-first formats, this offset will be negative.
+     */
+    sal_Int32 getScanlineStride() const;
+
+    /** Get pointer to frame buffer
+     */
+    RawMemorySharedPtr getBuffer() const;
+
+    /** Get pointer to palette
+
+        @return pointer to array of getPaletteEntryCount() Color
+        entries, if this is a palette format. If not, NULL is
+        returned.
+     */
+    const Color*    getPalette() const;
+
+    /** Query number of palette entries
+     */
+    const sal_Int32 getPaletteEntryCount() const;
+
+    /** Clear whole device with given color
+     */
+    void clear( Color fillColor );
+
+    /** Set given pixel to specified color
+
+        @param rPt
+        Pixel to set
+
+        @param pixelColor
+        Color value to set the pixel to
+
+        @param drawMode
+        Draw mode to use when changing the pixel value
+     */
+    void setPixel( const basegfx::B2IPoint& rPt,
+                   Color                    pixelColor,
+                   DrawMode                 drawMode );
+
+    /** Set given pixel to specified color
+
+        @param rPt
+        Pixel to set
+
+        @param pixelColor
+        Color value to set the pixel to
+
+        @param drawMode
+        Draw mode to use when changing the pixel value
+
+        @param rClip
+        Clip mask to use. If the clip mask is 0 at the given pixel
+        position, no change will happen.
+     */
+    void setPixel( const basegfx::B2IPoint&     rPt,
+                   Color                        pixelColor,
+                   DrawMode                     drawMode,
+                   const BitmapDeviceSharedPtr& rClip );
+
+    /** Get color value at given pixel
+     */
+    Color getPixel( const basegfx::B2IPoint& rPt );
+
+    /** Draw a line
+
+        @param rPt1
+        Start point of the line
+
+        @param rPt2
+        End point of the line. If the analytical line from rP1 to rPt2
+        (with the actual pixel positions are assumed to be the center
+        of the pixel) is exactly in the middle between two pixel, this
+        method always selects the pixel closer to rPt1.
+
+        @param lineColor
+        Color value to draw the line with
+
+        @param drawMode
+        Draw mode to use when changing the pixel value
+     */
+    void drawLine( const basegfx::B2IPoint& rPt1,
+                   const basegfx::B2IPoint& rPt2,
+                   Color                    lineColor,
+                   DrawMode                 drawMode );
+
+    /** Draw a line
+
+        @param rPt1
+        Start point of the line
+
+        @param rPt2
+        End point of the line. If the analytical line from rP1 to rPt2
+        (with the actual pixel positions are assumed to be the center
+        of the pixel) is exactly in the middle between two pixel, this
+        method always selects the pixel closer to rPt1.
+
+        @param lineColor
+        Color value to draw the line with
+
+        @param drawMode
+        Draw mode to use when changing the pixel value
+
+        @param rClip
+        Clip mask to use. Pixel where the corresponding clip mask
+        pixel is 0 will not be touched.
+     */
+    void drawLine( const basegfx::B2IPoint& rPt1,
+                   const basegfx::B2IPoint&     rPt2,
+                   Color                        lineColor,
+                   DrawMode                     drawMode,
+                   const BitmapDeviceSharedPtr& rClip );
+
+    void drawPolygon( const basegfx::B2DPolygon& rPoly,
+                      Color                      lineColor,
+                      DrawMode                   drawMode );
+    void drawPolygon( const basegfx::B2DPolygon&   rPoly,
+                      Color                        lineColor,
+                      DrawMode                     drawMode,
+                      const BitmapDeviceSharedPtr& rClip );
+
+    void fillPolyPolygon( const basegfx::B2DPolyPolygon& rPoly,
+                          Color                          fillColor,
+                          DrawMode                       drawMode );
+    void fillPolyPolygon( const basegfx::B2DPolyPolygon& rPoly,
+                          Color                          fillColor,
+                          DrawMode                       drawMode,
+                          const BitmapDeviceSharedPtr&   rClip );
+
+    void drawBitmap( const BitmapDeviceSharedPtr& rSrcBitmap,
+                     const basegfx::B2IRange&     rSrcRect,
+                     const basegfx::B2IRange&     rDstRect,
+                     DrawMode                     drawMode );
+    void drawBitmap( const BitmapDeviceSharedPtr& rSrcBitmap,
+                     const basegfx::B2IRange&     rSrcRect,
+                     const basegfx::B2IRange&     rDstRect,
+                     DrawMode                     drawMode,
+                     const BitmapDeviceSharedPtr& rClip );
+
+    void drawMaskedColor( Color                        rSrcColor,
+                          const BitmapDeviceSharedPtr& rAlphaMask,
+                          const basegfx::B2IRange&     rSrcRect,
+                          const basegfx::B2IPoint&     rDstPoint );
+    void drawMaskedColor( Color                        rSrcColor,
+                          const BitmapDeviceSharedPtr& rAlphaMask,
+                          const basegfx::B2IRange&     rSrcRect,
+                          const basegfx::B2IPoint&     rDstPoint,
+                          const BitmapDeviceSharedPtr& rClip );
+
+    void drawMaskedBitmap( const BitmapDeviceSharedPtr& rSrcBitmap,
+                           const BitmapDeviceSharedPtr& rMask,
+                           const basegfx::B2IRange&     rSrcRect,
+                           const basegfx::B2IRange&     rDstRect,
+                           DrawMode                     drawMode );
+    void drawMaskedBitmap( const BitmapDeviceSharedPtr& rSrcBitmap,
+                           const BitmapDeviceSharedPtr& rMask,
+                           const basegfx::B2IRange&     rSrcRect,
+                           const basegfx::B2IRange&     rDstRect,
+                           DrawMode                     drawMode,
+                           const BitmapDeviceSharedPtr& rClip );
+
+protected:
+    BitmapDevice( const basegfx::B2IVector& rSize,
+                  bool                      bTopDown,
+                  sal_Int32                 nScanlineFormat,
+                  sal_Int32                 nScanlineStride,
+                  const RawMemorySharedPtr& rMem );
+
+    virtual ~BitmapDevice();
+
+private:
+    virtual bool isCompatibleBitmap( const BitmapDeviceSharedPtr& bmp ) const = 0;
+    virtual bool isCompatibleClipMask( const BitmapDeviceSharedPtr& bmp ) const = 0;
+    virtual bool isCompatibleAlphaMask( const BitmapDeviceSharedPtr& bmp ) const = 0;
+
+    virtual const Color*    getPalette_i() const = 0;
+    virtual const sal_Int32 getPaletteEntryCount_i() const = 0;
+
+    virtual void clear_i( Color fillColor ) = 0;
+
+    virtual void setPixel_i( const basegfx::B2IPoint& rPt,
+                             Color                    lineColor,
+                             DrawMode                 drawMode ) = 0;
+    virtual void setPixel_i( const basegfx::B2IPoint&     rPt,
+                             Color                        lineColor,
+                             DrawMode                     drawMode,
+                             const BitmapDeviceSharedPtr& rClip ) = 0;
+
+    virtual Color getPixel_i( const basegfx::B2IPoint& rPt ) = 0;
+
+    virtual void drawLine_i( const basegfx::B2DPoint& rPt1,
+                             const basegfx::B2DPoint& rPt2,
+                             Color                    lineColor,
+                             DrawMode                 drawMode ) = 0;
+    virtual void drawLine_i( const basegfx::B2DPoint& rPt1,
+                             const basegfx::B2DPoint&     rPt2,
+                             Color                        lineColor,
+                             DrawMode                     drawMode,
+                             const BitmapDeviceSharedPtr& rClip ) = 0;
+
+    virtual void drawPolygon_i( const basegfx::B2DPolygon& rPoly,
+                                Color                      lineColor,
+                                DrawMode                   drawMode ) = 0;
+    virtual void drawPolygon_i( const basegfx::B2DPolygon&   rPoly,
+                                Color                        lineColor,
+                                DrawMode                     drawMode,
+                                const BitmapDeviceSharedPtr& rClip ) = 0;
+
+    virtual void fillPolyPolygon_i( const basegfx::B2DPolyPolygon& rPoly,
+                                    Color                          fillColor,
+                                    DrawMode                       drawMode,
+                                    const basegfx::B2IRange&       rBounds ) = 0;
+    virtual void fillPolyPolygon_i( const basegfx::B2DPolyPolygon& rPoly,
+                                    Color                          fillColor,
+                                    DrawMode                       drawMode,
+                                    const basegfx::B2IRange&       rBounds,
+                                    const BitmapDeviceSharedPtr&   rClip ) = 0;
+
+    // must work with *this == rSrcBitmap!
+    virtual void drawBitmap_i( const BitmapDeviceSharedPtr& rSrcBitmap,
+                               const basegfx::B2IRange&     rSrcRect,
+                               const basegfx::B2IRange&     rDstRect,
+                               DrawMode                     drawMode ) = 0;
+    virtual void drawBitmap_i( const BitmapDeviceSharedPtr& rSrcBitmap,
+                               const basegfx::B2IRange&     rSrcRect,
+                               const basegfx::B2IRange&     rDstRect,
+                               DrawMode                     drawMode,
+                               const BitmapDeviceSharedPtr& rClip ) = 0;
+
+    // must work with *this == rSrcBitmap!
+    virtual void drawMaskedColor_i( Color                        rSrcColor,
+                                    const BitmapDeviceSharedPtr& rAlphaMask,
+                                    const basegfx::B2IRange&     rSrcRect,
+                                    const basegfx::B2IPoint&     rDstPoint ) = 0;
+    virtual void drawMaskedColor_i( Color                        rSrcColor,
+                                    const BitmapDeviceSharedPtr& rAlphaMask,
+                                    const basegfx::B2IRange&     rSrcRect,
+                                    const basegfx::B2IPoint&     rDstPoint,
+                                    const BitmapDeviceSharedPtr& rClip ) = 0;
+
+    // must work with *this == rSrcBitmap!
+    virtual void drawMaskedBitmap_i( const BitmapDeviceSharedPtr& rSrcBitmap,
+                                     const BitmapDeviceSharedPtr& rMask,
+                                     const basegfx::B2IRange&     rSrcRect,
+                                     const basegfx::B2IRange&     rDstRect,
+                                     DrawMode                     drawMode ) = 0;
+    virtual void drawMaskedBitmap_i( const BitmapDeviceSharedPtr& rSrcBitmap,
+                                     const BitmapDeviceSharedPtr& rMask,
+                                     const basegfx::B2IRange&     rSrcRect,
+                                     const basegfx::B2IRange&     rDstRect,
+                                     DrawMode                     drawMode,
+                                     const BitmapDeviceSharedPtr& rClip ) = 0;
+
+    boost::scoped_ptr< ImplBitmapDevice > mpImpl;
+};
+
+/** Factory method to create a BitmapDevice for given scanline format
+ */
+BitmapDeviceSharedPtr createBitmapDevice( const basegfx::B2IVector& rSize,
+                                          bool                      bTopDown,
+                                          sal_Int32                 nScanlineFormat );
+
+}
+
+#endif /* INCLUDED_BASEBMP_BITMAPDEVICE_HXX */
diff --git a/basebmp/inc/basebmp/clippedlinerenderer.hxx b/basebmp/inc/basebmp/clippedlinerenderer.hxx
new file mode 100644
index 000000000000..92be0308a5c7
--- /dev/null
+++ b/basebmp/inc/basebmp/clippedlinerenderer.hxx
@@ -0,0 +1,370 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: clippedlinerenderer.hxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: thb $ $Date: 2006-05-31 09:49:41 $
+ *
+ *  The Contents of this file are made available subject to
+ *  the terms of GNU Lesser General Public License Version 2.1.
+ *
+ *
+ *    GNU Lesser General Public License Version 2.1
+ *    =============================================
+ *    Copyright 2005 by Sun Microsystems, Inc.
+ *    901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *    This library is free software; you can redistribute it and/or
+ *    modify it under the terms of the GNU Lesser General Public
+ *    License version 2.1, as published by the Free Software Foundation.
+ *
+ *    This library is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *    Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with this library; if not, write to the Free Software
+ *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *    MA  02111-1307  USA
+ *
+ ************************************************************************/
+
+#ifndef INCLUDED_BASEBMP_CLIPPEDLINERENDERER_HXX
+#define INCLUDED_BASEBMP_CLIPPEDLINERENDERER_HXX
+
+#include <basegfx/tools/rectcliptools.hxx>
+
+namespace basebmp
+{
+
+// factored-out bresenham setup code, which is used from two different
+// places in renderClippedLine() below. Admittedly messy for the long
+// parameter list...
+inline bool prepareClip( sal_Int32  a1,
+                         sal_Int32  a2,
+                         sal_Int32  b1,
+                         sal_Int32  da,
+                         sal_Int32  db,
+                         sal_Int32& o_as,
+                         sal_Int32& o_bs,
+                         int        sa,
+                         int        sb,
+                         sal_Int32& io_rem,
+                         int&       o_n,
+                         sal_uInt32 clipCode1,
+                         sal_uInt32 clipCount1,
+                         sal_uInt32 clipCode2,
+                         sal_uInt32 clipCount2,
+                         sal_Int32  aMin,
+                         sal_uInt32 aMinFlag,
+                         sal_Int32  aMax,
+                         sal_uInt32 aMaxFlag,
+                         sal_Int32  bMin,
+                         sal_uInt32 bMinFlag,
+                         sal_Int32  bMax,
+                         sal_uInt32 bMaxFlag,
+                         bool       bRoundTowardsPt2 )
+{
+    int ca, cb;
+    if( clipCode1 )
+    {
+        if( clipCode1 & aMinFlag )
+        {
+            ca = 2*db*(aMin - a1);
+            o_as = aMin;
+        }
+        else if( clipCode1 & aMaxFlag )
+        {
+            ca = 2*db*(a1 - aMax);
+            o_as = aMax;
+        }
+
+        if( clipCode1 & bMinFlag )
+        {
+            cb = 2*da*(bMin - b1);
+            o_bs = bMin;
+        }
+        else if( clipCode1 & bMaxFlag )
+        {
+            cb = 2*da*(b1 - bMax);
+            o_bs = bMax;
+        }
+
+        if( clipCount1 == 2 )
+            clipCode1 &= (ca + da < cb + !bRoundTowardsPt2) ? ~(aMin|aMax) : ~(bMin|bMax);
+
+        if( clipCode1 & (aMin|aMax) )
+        {
+            cb = (ca + da - !bRoundTowardsPt2) / (2*da);
+
+            if( sb >= 0 )
+            {
+                o_bs = b1 + cb;
+                if( o_bs > bMax )
+                    return;
+            }
+            else
+            {
+                o_bs = b1 - cb;
+                if( o_bs < bMin )
+                    return;
+            }
+
+            io_rem += ca - 2*da*cb;
+        }
+        else
+        {
+            ca = (cb - da + 2*db - bRoundTowardsPt2) / (2*db);
+            if( sa >= 0 )
+            {
+                o_as = a1 + ca;
+                if( o_as > aMax )
+                    return;
+            }
+            else
+            {
+                o_as = a1 - ca;
+                if( o_as < aMin )
+                    return;
+            }
+
+            io_rem += 2*db*ca - cb;
+        }
+    }
+    else
+    {
+        o_as = a1; o_bs = b1;
+    }
+
+    bool bRetVal = false;
+    if( clipCode2 )
+    {
+        if( clipCount2 == 2 )
+        {
+            ca = 2*db*((clipCode2 & aMin) ? a1 - aMin : aMax - a1);
+            cb = 2*da*((clipCode2 & bMin) ? b1 - bMin : bMax - b1);
+            clipCode2 &= (cb + da < ca + bRoundTowardsPt2) ? ~(aMin|aMax) : ~(bMin|bMax);
+        }
+
+        if( clipCode2 & (aMin|aMax) )
+            o_n = (clipCode2 & aMin) ? o_as - aMin : aMax - o_as;
+        else
+        {
+            o_n = (clipCode2 & bMin) ? o_bs - bMin : bMax - o_bs;
+            bRetVal = true;
+        }
+    }
+    else
+        o_n = (a2 >= o_as) ? a2 - o_as : o_as - a2;
+
+    return bRetVal;
+}
+
+
+/** Render line to image iterators, clip against given rectangle
+
+    This method renders a line from aPt1 to aPt2, clipped against
+    rClipRect (the clipping will take place pixel-perfect, i.e. as if
+    the original bresenham-rendered line would have been clipped each
+    pixel individually. No slight shifts compared to unclipped lines).
+
+    @param aPt1
+    Start point of the line
+
+    @param aPt2
+    End point of the line
+
+    @param rClipRect
+    Rectangle to clip against
+
+    @param color
+    Color value to render the line with
+
+    @param begin
+    left-top image iterator
+
+    @param end
+    right-bottom image iterator
+
+    @param acc
+    Image accessor
+
+    @param bRoundTowardsPt2
+    Rounding mode to use. Giving false here results in line pixel tend
+    towards pt1, i.e. when a pixel exactly hits the middle between two
+    pixel, the pixel closer to pt1 will be chosen. Giving true here
+    makes renderClippedLine() choose pt2 in those cases.
+ */
+template< class Iterator, class Accessor >
+void renderClippedLine( basegfx::B2IPoint             aPt1,
+                        basegfx::B2IPoint             aPt2,
+                        const basegfx::B2IRange&      rClipRect,
+                        typename Accessor::value_type color,
+                        Iterator                      begin,
+                        Iterator                      end,
+                        Accessor                      acc,
+                        bool                          bRoundTowardsPt2=false )
+{
+    // Algorithm according to Steven Eker's 'Pixel-perfect line clipping',
+    // Graphics Gems V, pp. 314-322
+    sal_uInt32 clipCode1 = basegfx::tools::getCohenSutherlandClipFlags(aPt1,
+                                                                       rClipRect);
+    sal_uInt32 clipCode2 = basegfx::tools::getCohenSutherlandClipFlags(aPt2,
+                                                                       rClipRect);
+
+    if( clipCode1 & clipCode2 )
+        return; // line fully clipped away
+
+    sal_uInt32 clipCount1 = basegfx::tools::getNumberOfClipPlanes(clipCode1);
+    sal_uInt32 clipCount2 = basegfx::tools::getNumberOfClipPlanes(clipCode2);
+
+    if( (clipCode1 != 0 && clipCode2 == 0)
+        || (clipCount1 == 2 && clipCount2 == 1) )
+    {
+        std::swap(clipCount2,clipCount1);
+        std::swap(clipCode2,clipCode1);
+        std::swap(aPt1,aPt2);
+        bRoundTowardsPt2 = !bRoundTowardsPt2;
+    }
+
+    const sal_Int32 x1 = aPt1.getX();
+    const sal_Int32 x2 = aPt2.getX();
+    const sal_Int32 y1 = aPt1.getY();
+    const sal_Int32 y2 = aPt2.getY();
+
+    // TODO(E1): This might overflow
+    sal_Int32 adx = x2 - x1;
+    int sx = 1;
+    if( adx < 0 )
+    {
+        adx *= -1;
+        sx = -1;
+    }
+
+    // TODO(E1): This might overflow
+    sal_Int32 ady = y2 - y1;
+    int sy = 1;
+    if( ady < 0 )
+    {
+        ady *= -1;
+        sy = -1;
+    }
+
+    int n  = 0;
+    sal_Int32 xs = x1;
+    sal_Int32 ys = y1;
+    if( adx >= ady )
+    {
+        // semi-horizontal line
+        sal_Int32 rem = 2*ady - adx - !bRoundTowardsPt2;
+
+        const bool bUseAlternateBresenham(
+            prepareClip(x1, x2, y1, adx, ady, xs, ys, sx, sy,
+                        rem, n, clipCode1, clipCount1, clipCode1, clipCount2,
+                        rClipRect.getMinX(), basegfx::tools::RectClipFlags::LEFT,
+                        rClipRect.getMaxX(), basegfx::tools::RectClipFlags::RIGHT,
+                        rClipRect.getMinY(), basegfx::tools::RectClipFlags::TOP,
+                        rClipRect.getMaxY(), basegfx::tools::RectClipFlags::BOTTOM,
+                        bRoundTowardsPt2 ));
+        const sal_Int32 diff = 2*(ady - adx);
+        if( bUseAlternateBresenham )
+        {
+            while(true)
+            {
+                plot(xs,ys);
+
+                if( rem >= 0 )
+                {
+                    if( --n < 0 )
+                        break;
+                    rem += diff;
+                    ys += sy;
+                }
+                else
+                    rem += 2*ady;
+
+                xs += sx;
+            }
+        }
+        else
+        {
+            while(true)
+            {
+                plot(xs,ys);
+
+                if( --n < 0 )
+                    break;
+                if( rem >= 0 )
+                {
+                    rem += diff;
+                    ys += sy;
+                }
+                else
+                    rem += 2*ady;
+
+                xs += sx;
+            }
+        }
+    }
+    else
+    {
+        // semi-vertical line
+        sal_Int32 rem = 2*adx - ady - !bRoundTowardsPt2;
+
+        const bool bUseAlternateBresenham(
+            prepareClip(y1, y2, x1, ady, adx, ys, xs, sy, sx,
+                        rem, clipCode1, clipCount1, clipCode1, clipCount2,
+                        rClipRect.getMinY(), basegfx::tools::RectClipFlags::TOP,
+                        rClipRect.getMaxY(), basegfx::tools::RectClipFlags::BOTTOM,
+                        rClipRect.getMinX(), basegfx::tools::RectClipFlags::LEFT,
+                        rClipRect.getMaxX(), basegfx::tools::RectClipFlags::RIGHT,
+                        bRoundTowardsPt2 ));
+        const sal_Int32 diff = 2*(ady - adx);
+        if( bUseAlternateBresenham )
+        {
+            while(true)
+            {
+                plot(xy,ys);
+
+                if( rem >= 0 )
+                {
+                    if( --n < 0 )
+                        break;
+                    rem += diff;
+                    xs += sx;
+                }
+                else
+                    rem += 2*adx;
+
+                ys += sy;
+            }
+        }
+        else
+        {
+            while(true)
+            {
+                plot(xs,ys);
+
+                if( --n < 0 )
+                    break;
+                if( rem >= 0 )
+                {
+                    rem += diff;
+                    xs += sx;
+                }
+                else
+                    rem += 2*adx;
+
+                ys += sy;
+            }
+        }
+    }
+}
+
+} // namespace basebmp
+
+#endif /* INCLUDED_BASEBMP_CLIPPEDLINERENDERER_HXX */
diff --git a/basebmp/inc/basebmp/color.hxx b/basebmp/inc/basebmp/color.hxx
new file mode 100644
index 000000000000..21ae86e897dd
--- /dev/null
+++ b/basebmp/inc/basebmp/color.hxx
@@ -0,0 +1,80 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: color.hxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: thb $ $Date: 2006-05-31 09:49:41 $
+ *
+ *  The Contents of this file are made available subject to
+ *  the terms of GNU Lesser General Public License Version 2.1.
+ *
+ *
+ *    GNU Lesser General Public License Version 2.1
+ *    =============================================
+ *    Copyright 2005 by Sun Microsystems, Inc.
+ *    901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *    This library is free software; you can redistribute it and/or
+ *    modify it under the terms of the GNU Lesser General Public
+ *    License version 2.1, as published by the Free Software Foundation.
+ *
+ *    This library is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *    Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with this library; if not, write to the Free Software
+ *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *    MA  02111-1307  USA
+ *
+ ************************************************************************/
+
+#ifndef INCLUDED_BASEBMP_COLOR_HXX
+#define INCLUDED_BASEBMP_COLOR_HXX
+
+#ifndef _SAL_TYPES_H_
+#include <sal/types.h>
+#endif
+#include <math.h>
+
+namespace basebmp
+{
+
+class Color
+{
+private:
+    sal_uInt32          mnColor;
+
+public:
+    Color() : mnColor(0) {}
+    Color( sal_uInt32 nVal ) : mnColor(nVal) {}
+    Color( sal_uInt8 nRed, sal_uInt8 nGreen, sal_uInt8 nBlue ) :
+        mnColor( (nRed << 16) | (nGreen << 8) | nBlue )
+    {}
+
+    void setRed( sal_uInt8 nRed ) { mnColor |= nRed << 16; mnColor &= ~((sal_uInt32)nRed << 16); }
+    void setGreen( sal_uInt8 nGreen ) { mnColor |= nGreen << 8; mnColor &= ~((sal_uInt32)nGreen << 8); }
+    void setBlue( sal_uInt8 nBlue ) { mnColor |= nBlue; mnColor &= ~(sal_uInt32)nBlue; }
+
+    sal_uInt8 getRed() const   { return (mnColor & 0x00FF0000U) >> 16; }
+    sal_uInt8 getGreen() const { return (mnColor & 0x0000FF00U) >> 8; }
+    sal_uInt8 getBlue() const  { return mnColor & 0x000000FFU; }
+
+    sal_uInt32 getValue() const { return mnColor; }
+    operator sal_uInt32() const { return mnColor; }
+
+    Color operator-( Color col ) const { return Color(getRed()-col.getRed(),
+                                                      getGreen()-col.getGreen(),
+                                                      getBlue()-col.getBlue()); }
+    double magnitude() const { return sqrt(getRed()*getRed()
+                                           + getGreen()*getGreen()
+                                           + getBlue()*getBlue()); }
+};
+
+} // namespace basebmp
+
+#endif /* INCLUDED_BASEBMP_COLOR_HXX */
diff --git a/basebmp/inc/basebmp/debug.hxx b/basebmp/inc/basebmp/debug.hxx
new file mode 100644
index 000000000000..62cc8eaeb646
--- /dev/null
+++ b/basebmp/inc/basebmp/debug.hxx
@@ -0,0 +1,58 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: debug.hxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: thb $ $Date: 2006-05-31 09:49:42 $
+ *
+ *  The Contents of this file are made available subject to
+ *  the terms of GNU Lesser General Public License Version 2.1.
+ *
+ *
+ *    GNU Lesser General Public License Version 2.1
+ *    =============================================
+ *    Copyright 2005 by Sun Microsystems, Inc.
+ *    901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *    This library is free software; you can redistribute it and/or
+ *    modify it under the terms of the GNU Lesser General Public
+ *    License version 2.1, as published by the Free Software Foundation.
+ *
+ *    This library is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *    Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with this library; if not, write to the Free Software
+ *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *    MA  02111-1307  USA
+ *
+ ************************************************************************/
+
+#ifndef INCLUDED_BASEBMP_DEBUG_HXX
+#define INCLUDED_BASEBMP_DEBUG_HXX
+
+#include <iostream>
+#include <boost/shared_ptr.hpp>
+
+namespace basebmp
+{
+    class BitmapDevice;
+
+    /** Dump content of BitmapDevice to given output stream.
+
+        @param rDevice
+        Device whose content should be dumped.
+
+        @param rOutputStream
+        Stream to write output to.
+    */
+    void debugDump( const boost::shared_ptr< BitmapDevice >& rDevice,
+                    ::std::ostream&                          rOutputStream );
+}
+
+#endif /* INCLUDED_BASEBMP_DEBUG_HXX */
diff --git a/basebmp/inc/basebmp/drawmodes.hxx b/basebmp/inc/basebmp/drawmodes.hxx
new file mode 100644
index 000000000000..f09d5c221383
--- /dev/null
+++ b/basebmp/inc/basebmp/drawmodes.hxx
@@ -0,0 +1,76 @@
+/*************************************************************************
+ *
+ *  $RCSfile: drawmodes.hxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: thb $ $Date: 2006-05-31 09:49:42 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *  MA  02111-1307  USA
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (the "License"); You may not use this file
+ *  except in compliance with the License. You may obtain a copy of the
+ *  License at http://www.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+
+#ifndef INCLUDED_BASEBMP_DRAWMODES_HXX
+#define INCLUDED_BASEBMP_DRAWMODES_HXX
+
+/* Definition of Draw modes */
+
+namespace basebmp
+{
+    enum DrawMode
+    {
+        DrawMode_PAINT,
+        DrawMode_XOR
+    };
+}
+
+#endif /* INCLUDED_BASEBMP_DRAWMODES_HXX */
diff --git a/basebmp/inc/basebmp/linerenderer.hxx b/basebmp/inc/basebmp/linerenderer.hxx
new file mode 100644
index 000000000000..0493e9571b8a
--- /dev/null
+++ b/basebmp/inc/basebmp/linerenderer.hxx
@@ -0,0 +1,186 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: linerenderer.hxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: thb $ $Date: 2006-05-31 09:49:42 $
+ *
+ *  The Contents of this file are made available subject to
+ *  the terms of GNU Lesser General Public License Version 2.1.
+ *
+ *
+ *    GNU Lesser General Public License Version 2.1
+ *    =============================================
+ *    Copyright 2005 by Sun Microsystems, Inc.
+ *    901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *    This library is free software; you can redistribute it and/or
+ *    modify it under the terms of the GNU Lesser General Public
+ *    License version 2.1, as published by the Free Software Foundation.
+ *
+ *    This library is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *    Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with this library; if not, write to the Free Software
+ *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *    MA  02111-1307  USA
+ *
+ ************************************************************************/
+
+#ifndef INCLUDED_BASEBMP_LINERENDERER_HXX
+#define INCLUDED_BASEBMP_LINERENDERER_HXX
+
+#ifndef _BGFX_POINT_B2IPOINT_HXX
+#include <basegfx/point/b2ipoint.hxx>
+#endif
+
+/* Scan-converting lines */
+
+namespace basebmp
+{
+
+/** Render line with Bresenham
+
+    This function renders the line given by rPt1 and rPt2 using the
+    Bresenham algorithm with the specified color value. Make sure rPt1
+    and rPt1 are valid coordinates in the image given by begin and
+    end, since no clipping takes place.
+
+    @param aPt1
+    Start point of the line
+
+    @param aPt2
+    End point of the line
+
+    @param color
+    Color value to render the line with
+
+    @param begin
+    left-top image iterator
+
+    @param end
+    right-bottom image iterator
+
+    @param acc
+    Image accessor
+
+    @param bRoundTowardsPt2
+    Rounding mode to use. Giving false here results in line pixel tend
+    towards pt1, i.e. when a pixel exactly hits the middle between two
+    pixel, the pixel closer to pt1 will be chosen. Giving true here
+    makes renderClippedLine() choose pt2 in those cases.
+ */
+template< class Iterator, class Accessor >
+void renderLine( const basegfx::B2IPoint&      rPt1,
+                 const basegfx::B2IPoint&      rPt2,
+                 typename Accessor::value_type color,
+                 Iterator                      begin,
+                 Iterator                      end,
+                 Accessor                      acc,
+                 bool                          bRoundTowardsPt2=false )
+{
+    // code inspired by Paul Heckbert's Digital Line Drawing
+    // (Graphics Gems, Academic Press 1990)
+    const sal_Int32 x1 = rPt1.getX();
+    const sal_Int32 x2 = rPt2.getX();
+    const sal_Int32 y1 = rPt1.getY();
+    const sal_Int32 y2 = rPt2.getY();
+
+    // TODO(E1): This might overflow
+    sal_Int32 adx = x2 - x1;
+    int sx = 1;
+    if( adx < 0 )
+    {
+        adx *= -1;
+        sx = -1;
+    }
+
+    // TODO(E1): This might overflow
+    sal_Int32 ady = y2 - y1;
+    int sy = 1;
+    if( ady < 0 )
+    {
+        ady *= -1;
+        sy = -1;
+    }
+
+    // TODO(P3): handle horizontal and vertical lines specially
+    sal_Int32 xs = x1;
+    sal_Int32 ys = y1;
+    if( adx >= ady )
+    {
+        // semi-horizontal line
+        sal_Int32 rem = 2*ady - adx - !bRoundTowardsPt2;
+        adx *= 2;
+        ady *= 2;
+
+        Iterator currIter( begin + vigra::Diff2D(0,ys) );
+        typename Iterator::row_iterator rowIter( currIter.rowIterator() + xs );
+        while(true)
+        {
+            acc.set(color, rowIter);
+
+            if( xs == x2 )
+                return;
+
+            if( rem >= 0 )
+            {
+                ys += sy;
+                xs += sx;
+                currIter.y += sy;
+                rowIter = currIter.rowIterator() + xs;
+                rem -= adx;
+            }
+            else
+            {
+                xs += sx;
+                rowIter += sx;
+            }
+
+            rem += ady;
+        }
+    }
+    else
+    {
+        // semi-vertical line
+        sal_Int32 rem = 2*adx - ady - !bRoundTowardsPt2;
+        adx *= 2;
+        ady *= 2;
+
+        Iterator currIter( begin + vigra::Diff2D(xs,0) );
+        typename Iterator::column_iterator colIter( currIter.columnIterator() + ys );
+        while(true)
+        {
+            acc.set(color, colIter);
+
+            if( ys == y2 )
+                return;
+
+            if( rem >= 0 )
+            {
+                xs += sx;
+                ys += sy;
+                currIter.x += sx;
+                colIter = currIter.columnIterator() + ys;
+                rem -= ady;
+            }
+            else
+            {
+                ys += sy;
+                colIter += sy;
+            }
+
+            rem += adx;
+        }
+    }
+}
+
+} // namespace basebmp
+
+#endif /* INCLUDED_BASEBMP_LINERENDERER_HXX */
diff --git a/basebmp/inc/basebmp/metafunctions.hxx b/basebmp/inc/basebmp/metafunctions.hxx
new file mode 100644
index 000000000000..cdef37548e7b
--- /dev/null
+++ b/basebmp/inc/basebmp/metafunctions.hxx
@@ -0,0 +1,79 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: metafunctions.hxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: thb $ $Date: 2006-05-31 09:49:42 $
+ *
+ *  The Contents of this file are made available subject to
+ *  the terms of GNU Lesser General Public License Version 2.1.
+ *
+ *
+ *    GNU Lesser General Public License Version 2.1
+ *    =============================================
+ *    Copyright 2005 by Sun Microsystems, Inc.
+ *    901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *    This library is free software; you can redistribute it and/or
+ *    modify it under the terms of the GNU Lesser General Public
+ *    License version 2.1, as published by the Free Software Foundation.
+ *
+ *    This library is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *    Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with this library; if not, write to the Free Software
+ *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *    MA  02111-1307  USA
+ *
+ ************************************************************************/
+
+#ifndef INCLUDED_BASEBMP_METAFUNCTIONS_HXX
+#define INCLUDED_BASEBMP_METAFUNCTIONS_HXX
+
+namespace basebmp
+{
+
+// TODO(Q3): move to generic place (o3tl?)
+
+/// template meta function: add const qualifier, if given 2nd type has it
+template<typename A, typename B> struct clone_const
+{
+    typedef B type;
+};
+template<typename A, typename B> struct clone_const<const A,B>
+{
+    typedef const B type;
+};
+
+/// template meta function: remove const qualifier from plain type
+template <typename T> struct remove_const
+{
+    typedef T type;
+};
+template <typename T> struct remove_const<const T>
+{
+    typedef T type;
+};
+
+/// returns true, if given number is strictly less than 0
+template< typename T > inline bool is_negative( T x )
+{
+    return x < 0;
+}
+
+/// Overload for ints (branch-free)
+inline bool is_negative( int x )
+{
+    // force logic shift (result for signed shift right is undefined)
+    return static_cast<unsigned int>(x) >> (sizeof(int)*8-1);
+}
+
+} // namespace basebmp
+
+#endif /* INCLUDED_BASEBMP_METAFUNCTIONS_HXX */
diff --git a/basebmp/inc/basebmp/packedpixeliterator.hxx b/basebmp/inc/basebmp/packedpixeliterator.hxx
new file mode 100644
index 000000000000..48330d5c27ad
--- /dev/null
+++ b/basebmp/inc/basebmp/packedpixeliterator.hxx
@@ -0,0 +1,676 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: packedpixeliterator.hxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: thb $ $Date: 2006-05-31 09:49:42 $
+ *
+ *  The Contents of this file are made available subject to
+ *  the terms of GNU Lesser General Public License Version 2.1.
+ *
+ *
+ *    GNU Lesser General Public License Version 2.1
+ *    =============================================
+ *    Copyright 2005 by Sun Microsystems, Inc.
+ *    901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *    This library is free software; you can redistribute it and/or
+ *    modify it under the terms of the GNU Lesser General Public
+ *    License version 2.1, as published by the Free Software Foundation.
+ *
+ *    This library is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *    Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with this library; if not, write to the Free Software
+ *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *    MA  02111-1307  USA
+ *
+ ************************************************************************/
+
+#ifndef INCLUDED_BASEBMP_PACKEDPIXELITERATOR_HXX
+#define INCLUDED_BASEBMP_PACKEDPIXELITERATOR_HXX
+
+#include "metafunctions.hxx"
+#include "stridedarrayiterator.hxx"
+
+#include <boost/static_assert.hpp>
+#include <vigra/metaprogramming.hxx>
+#include <vigra/diff2d.hxx>
+
+namespace basebmp
+{
+
+/// Get bitmask for data at given intra-word position, for given bit depth
+template< typename data_type, int bits_per_pixel, bool MsbFirst, typename difference_type > inline data_type get_mask( difference_type d )
+{
+    BOOST_STATIC_ASSERT(bits_per_pixel > 0);
+    BOOST_STATIC_ASSERT(sizeof(data_type)*8 % bits_per_pixel == 0);
+    BOOST_STATIC_ASSERT(sizeof(data_type)*8 / bits_per_pixel > 1);
+    BOOST_STATIC_ASSERT(vigra::TypeTraits<data_type>::isPOD::asBool);
+
+    const unsigned int nIntraWordPositions( sizeof(data_type)*8 / bits_per_pixel );
+
+    //      create bits_per_pixel 1s      shift to intra-word position
+    return ((~(~0 << bits_per_pixel)) << bits_per_pixel*(MsbFirst ?
+                                                         (nIntraWordPositions-1 - (d % nIntraWordPositions)) :
+                                                         (d % nIntraWordPositions)));
+}
+
+template< int num_intraword_positions, int bits_per_pixel, bool MsbFirst, typename difference_type > inline difference_type get_shift( difference_type remainder )
+{
+    return bits_per_pixel*(MsbFirst ?
+                           (num_intraword_positions - 1 - remainder) :
+                           remainder);
+}
+
+template< typename Datatype,
+          typename Valuetype,
+          int      bits_per_pixel,
+          bool     MsbFirst > class PackedPixelColumnIterator
+{
+public:
+    // no reference, no index_reference type here
+    typedef Datatype                                    data_type;
+    typedef Valuetype                                   value_type;
+    typedef int                                         difference_type;
+    typedef image_traverser_tag                         iterator_category;
+
+    typedef typename remove_const<data_type>::type      mask_type;
+    typedef data_type*                                  pointer;
+    typedef StridedArrayIterator< data_type >           MoveY;
+
+    enum {
+        /** The number of pixel within a single data_type value
+         */
+        num_intraword_positions=sizeof(data_type)*8/bits_per_pixel,
+        /** Bit mask for one pixel (least significant bits)
+         */
+        bit_mask=~(~0 << bits_per_pixel)
+    };
+
+private:
+    MoveY           y;
+    mask_type       mask_;
+    difference_type shift_;
+
+    void inc()
+    {
+        ++y;
+    }
+
+    void dec()
+    {
+        --y;
+    }
+
+    bool equal( PackedPixelColumnIterator const & rhs ) const
+    {
+        return rhs.y == y;
+    }
+
+    bool less( PackedPixelColumnIterator const & rhs ) const
+    {
+        return y < rhs.y;
+    }
+
+public:
+    PackedPixelColumnIterator() :
+        y(0),
+        mask_( get_mask<data_type, bits_per_pixel, MsbFirst, difference_type>(0) ),
+        shift_( get_shift<num_intraword_positions, bits_per_pixel, MsbFirst, difference_type>(0) )
+    {}
+
+    PackedPixelColumnIterator( const MoveY& base, difference_type remainder ) :
+        y(base),
+        mask_( get_mask<data_type, bits_per_pixel, MsbFirst>(remainder) ),
+        shift_( get_shift<num_intraword_positions, bits_per_pixel, MsbFirst>(remainder) )
+    {}
+
+    PackedPixelColumnIterator& operator+=( difference_type d )
+    {
+        y += d;
+        return *this;
+    }
+
+    PackedPixelColumnIterator& operator-=( difference_type d )
+    {
+        y -= d;
+        return *this;
+    }
+
+    PackedPixelColumnIterator operator+( difference_type d )
+    {
+        PackedPixelColumnIterator res(*this);
+        res += d;
+        return res;
+    }
+
+    PackedPixelColumnIterator operator-( difference_type d )
+    {
+        PackedPixelColumnIterator res(*this);
+        res -= d;
+        return res;
+    }
+
+    PackedPixelColumnIterator& operator++()
+    {
+        inc();
+        return *this;
+    }
+
+    PackedPixelColumnIterator& operator--()
+    {
+        dec();
+        return *this;
+    }
+
+    PackedPixelColumnIterator operator++(int)
+    {
+        PackedPixelColumnIterator res(*this);
+        inc();
+        return res;
+    }
+
+    PackedPixelColumnIterator operator--(int)
+    {
+        PackedPixelColumnIterator res(*this);
+        dec();
+        return res;
+    }
+
+    bool operator==(PackedPixelColumnIterator const & rhs) const
+    {
+        return equal( rhs );
+    }
+
+    bool operator!=(PackedPixelColumnIterator const & rhs) const
+    {
+        return !equal( rhs );
+    }
+
+    bool operator<(PackedPixelColumnIterator const & rhs) const
+    {
+        return less(rhs);
+    }
+
+    bool operator<=(PackedPixelColumnIterator const & rhs) const
+    {
+        return !less(rhs);
+    }
+
+    bool operator>(PackedPixelColumnIterator const & rhs) const
+    {
+        return rhs.less(*this);
+    }
+
+    bool operator>=(PackedPixelColumnIterator const & rhs) const
+    {
+        return !rhs.less(*this);
+    }
+
+    difference_type operator-(PackedPixelColumnIterator const & rhs) const
+    {
+        return y - rhs.y;
+    }
+
+    value_type get() const
+    {
+        // TODO(Q3): use traits to get unsigned type for data_type (if
+        // not already)
+        return static_cast<unsigned int>(*y() & mask_) >> shift_;
+    }
+
+    value_type get(difference_type d) const
+    {
+        // TODO(Q3): use traits to get unsigned type for data_type (if
+        // not already)
+        return static_cast<unsigned int>(*y(d) & mask_) >> shift_;
+    }
+
+    void set( value_type v ) const
+    {
+        const value_type pixel_value( (v << shift_) & mask_ );
+        *y() = (*y() & ~mask_) | pixel_value;
+    }
+
+    void set( value_type v, difference_type d ) const
+    {
+        const value_type pixel_value( (v << shift_) & mask_ );
+        *y(d) = (*y(d) & ~mask_) | pixel_value;
+    }
+};
+
+template< typename Datatype,
+          typename Valuetype,
+          int      bits_per_pixel,
+          bool     MsbFirst > class PackedPixelRowIterator
+{
+public:
+    // no reference, no index_reference type here
+    typedef Datatype                                    data_type;
+    typedef Valuetype                                   value_type;
+    typedef int                                         difference_type;
+    typedef image_traverser_tag                         iterator_category;
+
+    typedef typename remove_const<data_type>::type      mask_type;
+    typedef data_type*                                  pointer;
+
+    enum {
+        /** The number of pixel within a single data_type value
+         */
+        num_intraword_positions=sizeof(data_type)*8/bits_per_pixel,
+        /** Bit mask for one pixel (least significant bits)
+         */
+        bit_mask=~(~0 << bits_per_pixel)
+    };
+
+private:
+    pointer         data_;
+    mask_type       mask_;
+    difference_type remainder_;
+
+    void update_mask()
+    {
+        mask_ = get_mask<data_type, bits_per_pixel, MsbFirst>(remainder_);
+    }
+
+    void inc()
+    {
+        const difference_type newValue( remainder_ + 1 );
+        const difference_type data_offset( newValue / num_intraword_positions );
+
+        data_ += data_offset;
+        remainder_ = newValue % num_intraword_positions;
+
+        const mask_type shifted_mask(
+            MsbFirst ?
+            // TODO(Q3): use traits to get unsigned type for data_type
+            // (if not already)
+            static_cast<unsigned int>(mask_) >> bits_per_pixel :
+            mask_ << bits_per_pixel );
+
+        // data_offset is 0 for shifted mask, and 1 for wrapped-around mask
+        mask_ = (1-data_offset)*shifted_mask + data_offset*(MsbFirst ?
+                                                            bit_mask << bits_per_pixel*(num_intraword_positions-1) :
+                                                            bit_mask);
+    }
+
+    void dec()
+    {
+        const difference_type newValue( remainder_ - 1 );
+        const bool            isNegative( is_negative(newValue) );
+        const difference_type newRemainder( newValue % num_intraword_positions );
+
+        // calc  data_ += newValue / num_intraword_positions;
+        //       remainder_ = newRemainder;
+        // for newValue >= 0, and
+        //       data_ += newValue / num_intraword_positions - 1;
+        //       remainder_ = num_intraword_positions - newRemainder;
+        // (to force remainder_ to be positive).
+        // This is branch-free, if is_negative() is branch-free
+        const difference_type data_offset( newValue / num_intraword_positions - isNegative );
+        data_     += data_offset;
+        remainder_ = newRemainder + isNegative*num_intraword_positions;
+
+        const mask_type shifted_mask(
+            MsbFirst ?
+            mask_ << bits_per_pixel :
+            // TODO(Q3): use traits to get unsigned type for data_type
+            // (if not already)
+            static_cast<unsigned int>(mask_) >> bits_per_pixel );
+
+        // data_offset is 0 for shifted mask, and 1 for wrapped-around mask
+        mask_ = (1-data_offset)*shifted_mask + data_offset*(MsbFirst ?
+                                                            bit_mask :
+                                                            bit_mask << bits_per_pixel*(num_intraword_positions-1));
+    }
+
+    bool equal( PackedPixelRowIterator const & rhs ) const
+    {
+        return rhs.data_ == data_ && rhs.remainder_ == remainder_;
+    }
+
+    bool less( PackedPixelRowIterator const & rhs ) const
+    {
+        return data_ == rhs.data_ ?
+            (remainder_ < rhs.remainder_) :
+            (data_ < rhs.data_);
+    }
+
+public:
+    PackedPixelRowIterator() :
+        data_(0),
+        mask_( get_mask<data_type, bits_per_pixel, MsbFirst, difference_type>(0) ),
+        remainder_(0)
+    {}
+
+    explicit PackedPixelRowIterator( pointer base, int x ) :
+        data_(base),
+        mask_(0),
+        remainder_(x % num_intraword_positions)
+    {
+        update_mask();
+    }
+
+    PackedPixelRowIterator& operator+=( difference_type d )
+    {
+        const difference_type newValue( remainder_ + d );
+
+        data_ += newValue / num_intraword_positions;
+        remainder_ = newValue % num_intraword_positions;
+        update_mask();
+
+        return *this;
+    }
+
+    PackedPixelRowIterator& operator-=( difference_type d )
+    {
+        const difference_type newValue( remainder_ - d );
+        const bool            isNegative( is_negative(newValue) );
+        const difference_type newRemainder( newValue % num_intraword_positions );
+
+        // calc  data_ += newValue / num_intraword_positions;
+        //       remainder_ = newRemainder;
+        // for newValue >= 0, and
+        //       data_ += newValue / num_intraword_positions - 1;
+        //       remainder_ = num_intraword_positions - newRemainder;
+        // (to force remainder_ to be positive).
+        // This is branch-free, if is_negative() is branch-free
+        data_     += newValue / num_intraword_positions - isNegative;
+        remainder_ = newRemainder + isNegative*(num_intraword_positions - 2*newRemainder);
+        update_mask();
+
+        return *this;
+    }
+
+    PackedPixelRowIterator operator+( difference_type d )
+    {
+        PackedPixelRowIterator res(*this);
+        res += d;
+        return res;
+    }
+
+    PackedPixelRowIterator operator-( difference_type d )
+    {
+        PackedPixelRowIterator res(*this);
+        res -= d;
+        return res;
+    }
+
+    PackedPixelRowIterator& operator++()
+    {
+        inc();
+        return *this;
+    }
+
+    PackedPixelRowIterator& operator--()
+    {
+        dec();
+        return *this;
+    }
+
+    PackedPixelRowIterator operator++(int)
+    {
+        PackedPixelRowIterator res(*this);
+        inc();
+        return res;
+    }
+
+    PackedPixelRowIterator operator--(int)
+    {
+        PackedPixelRowIterator res(*this);
+        dec();
+        return res;
+    }
+
+    bool operator==(PackedPixelRowIterator const & rhs) const
+    {
+        return equal( rhs );
+    }
+
+    bool operator!=(PackedPixelRowIterator const & rhs) const
+    {
+        return !equal( rhs );
+    }
+
+    bool operator<(PackedPixelRowIterator const & rhs) const
+    {
+        return less(rhs);
+    }
+
+    bool operator<=(PackedPixelRowIterator const & rhs) const
+    {
+        return !less(rhs);
+    }
+
+    bool operator>(PackedPixelRowIterator const & rhs) const
+    {
+        return rhs.less(*this);
+    }
+
+    bool operator>=(PackedPixelRowIterator const & rhs) const
+    {
+        return !rhs.less(*this);
+    }
+
+    difference_type operator-(PackedPixelRowIterator const & rhs) const
+    {
+        return (data_ - rhs.data_)*num_intraword_positions + (remainder_ - rhs.remainder_);
+    }
+
+    value_type get() const
+    {
+        // TODO(Q3): use traits to get unsigned type for data_type (if
+        // not already)
+        return static_cast<unsigned int>(*data_ & mask_) >>
+            get_shift<num_intraword_positions, bits_per_pixel, MsbFirst>(remainder_);
+    }
+
+    value_type get(difference_type d) const
+    {
+        PackedPixelRowIterator tmp(*this);
+        tmp += d;
+        return tmp.get();
+    }
+
+    void set( value_type v ) const
+    {
+        const value_type pixel_value(
+            (v <<
+             get_shift<num_intraword_positions, bits_per_pixel, MsbFirst>(remainder_))
+            & mask_ );
+        *data_ = (*data_ & ~mask_) | pixel_value;
+    }
+
+    void set( value_type v, difference_type d ) const
+    {
+        PackedPixelRowIterator tmp(*this);
+        tmp += d;
+        tmp.set(v);
+    }
+};
+
+template< typename Datatype,
+          typename Valuetype,
+          int      bits_per_pixel,
+          bool     MsbFirst > class PackedPixelIterator
+{
+public:
+    // no reference, no index_reference type here
+    typedef Datatype                                    data_type;
+    typedef Valuetype                                   value_type;
+    typedef vigra::Diff2D                               difference_type;
+    typedef image_traverser_tag                         iterator_category;
+    typedef PackedPixelRowIterator<data_type,
+                                   value_type,
+                                   bits_per_pixel,
+                                   MsbFirst>            row_iterator;
+    typedef PackedPixelColumnIterator<data_type,
+                                      value_type,
+                                      bits_per_pixel,
+                                      MsbFirst>         column_iterator;
+
+    typedef data_type*                                  pointer;
+    typedef int                                         MoveX;
+    typedef StridedArrayIterator< data_type >           MoveY;
+
+    enum {
+        /** The number of pixel within a single data_type value
+         */
+        num_intraword_positions=sizeof(data_type)*8/bits_per_pixel,
+        /** Bit mask for one pixel (least significant bits)
+         */
+        bit_mask=~(~0 << bits_per_pixel)
+    };
+
+    // TODO(F2): direction of iteration (ImageIterator can be made to
+    // run backwards)
+
+private:
+    pointer current() const
+    {
+        return y() + (x / num_intraword_positions);
+    }
+
+    pointer current(int dx, int dy) const
+    {
+        return y(dy) + ((x+dx)/num_intraword_positions);
+    }
+
+    bool equal(PackedPixelIterator const & rhs) const
+    {
+        return (x == rhs.x) && (y == rhs.y);
+    }
+
+public:
+    PackedPixelIterator() :
+        x(0),
+        y(0)
+    {}
+
+    PackedPixelIterator(pointer base, int ystride) :
+        x(0),
+        y(ystride,base)
+    {}
+
+    bool operator==(PackedPixelIterator const & rhs) const
+    {
+        return equal(rhs);
+    }
+
+    bool operator!=(PackedPixelIterator const & rhs) const
+    {
+        return !equal(rhs);
+    }
+
+    difference_type operator-(PackedPixelIterator const & rhs) const
+    {
+        return difference_type(x - rhs.x, y - rhs.y);
+    }
+
+    MoveX x;
+    MoveY y;
+
+    PackedPixelIterator & operator+=(difference_type const & s)
+    {
+        x += s.x;
+        y += s.y;
+        return *this;
+    }
+
+    PackedPixelIterator & operator-=(difference_type const & s)
+    {
+        x -= s.x;
+        y -= s.y;
+        return *this;
+    }
+
+    PackedPixelIterator operator+(difference_type const & s) const
+    {
+        PackedPixelIterator ret(*this);
+        ret += s;
+        return ret;
+    }
+
+    PackedPixelIterator operator-(difference_type const & s) const
+    {
+        PackedPixelIterator ret(*this);
+        ret -= s;
+        return ret;
+    }
+
+    row_iterator rowIterator() const
+    {
+        return row_iterator(current(),x);
+    }
+
+    column_iterator columnIterator() const
+    {
+        return column_iterator(MoveY(y,
+                                     x / num_intraword_positions),
+                               x % num_intraword_positions);
+    }
+
+    value_type get() const
+    {
+        const int remainder( x % num_intraword_positions );
+
+        // TODO(Q3): use traits to get unsigned type for data_type (if
+        // not already)
+        value_type nTmp0( *current() );
+        unsigned int nTmp1(static_cast<unsigned int>(*current() &
+                                                     get_mask<data_type, bits_per_pixel, MsbFirst>(remainder)));
+        unsigned int nTmp2( (static_cast<unsigned int>(*current() &
+                                                       get_mask<data_type, bits_per_pixel, MsbFirst>(remainder))
+                             >> get_shift<num_intraword_positions, bits_per_pixel, MsbFirst>(remainder)));
+
+        return (static_cast<unsigned int>(*current() &
+                                          get_mask<data_type, bits_per_pixel, MsbFirst>(remainder))
+                >> get_shift<num_intraword_positions, bits_per_pixel, MsbFirst>(remainder));
+    }
+
+    value_type get(difference_type const & d) const
+    {
+        const int remainder( x(d.x) % num_intraword_positions );
+
+        // TODO(Q3): use traits to get unsigned type for data_type (if
+        // not already)
+        return (static_cast<unsigned int>(*current(d.x,d.y) &
+                                          get_mask<data_type, bits_per_pixel, MsbFirst>(remainder))
+                >> get_shift<num_intraword_positions, bits_per_pixel, MsbFirst>(remainder));
+    }
+
+    void set( value_type v ) const
+    {
+        const int remainder( x % num_intraword_positions );
+        const int mask( get_mask<data_type, bits_per_pixel, MsbFirst>(remainder) );
+        const value_type pixel_value(
+            (v <<
+             get_shift<num_intraword_positions, bits_per_pixel, MsbFirst>(remainder))
+            & mask );
+        pointer p = current();
+        *p = (*p & ~mask) | pixel_value;
+    }
+
+    void set( value_type v, difference_type const & d ) const
+    {
+        const int remainder( (x + d.x) % num_intraword_positions );
+        const int mask( get_mask<data_type, bits_per_pixel, MsbFirst>(remainder) );
+        const value_type pixel_value(
+            (v <<
+             get_shift<num_intraword_positions, bits_per_pixel, MsbFirst>(remainder))
+             & mask );
+        pointer p = current(d.x,d.y);
+        *p = (*p & ~mask) | pixel_value;
+    }
+};
+
+} // namespace basebmp
+
+#endif /* INCLUDED_BASEBMP_PACKEDPIXELITERATOR_HXX */
diff --git a/basebmp/inc/basebmp/paletteimageaccessor.hxx b/basebmp/inc/basebmp/paletteimageaccessor.hxx
new file mode 100644
index 000000000000..848ea59d7a50
--- /dev/null
+++ b/basebmp/inc/basebmp/paletteimageaccessor.hxx
@@ -0,0 +1,141 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: paletteimageaccessor.hxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: thb $ $Date: 2006-05-31 09:49:42 $
+ *
+ *  The Contents of this file are made available subject to
+ *  the terms of GNU Lesser General Public License Version 2.1.
+ *
+ *
+ *    GNU Lesser General Public License Version 2.1
+ *    =============================================
+ *    Copyright 2005 by Sun Microsystems, Inc.
+ *    901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *    This library is free software; you can redistribute it and/or
+ *    modify it under the terms of the GNU Lesser General Public
+ *    License version 2.1, as published by the Free Software Foundation.
+ *
+ *    This library is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *    Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with this library; if not, write to the Free Software
+ *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *    MA  02111-1307  USA
+ *
+ ************************************************************************/
+
+#ifndef INCLUDED_BASEBMP_PALETTEIMAGEACCESSOR_HXX
+#define INCLUDED_BASEBMP_PALETTEIMAGEACCESSOR_HXX
+
+#include "metafunctions.hxx"
+
+#include <vigra/numerictraits.hxx>
+#include <vigra/mathutil.hxx>
+
+#include <algorithm>
+
+
+namespace basebmp
+{
+
+/** Access (possibly packed-pixel) data via palette indirection
+ */
+template< typename Valuetype, typename Datatype > class PaletteImageAccessor
+{
+public:
+    typedef Valuetype                                   value_type;
+    typedef Datatype                                    data_type;
+    typedef typename remove_const<data_type>::type      count_type;
+
+
+private:
+    const value_type* palette;
+    count_type        num_entries;
+
+    double norm( value_type const& rLHS,
+                 value_type const& rRHS ) const
+    {
+        return (rRHS - rLHS).magnitude();
+    }
+
+    data_type find_best_match(value_type const& v) const
+    {
+        // TODO(P3): use table-based/octree approach here!
+        const value_type* best_entry;
+        const value_type* palette_end( palette+num_entries );
+        if( (best_entry=std::find( palette, palette_end, v)) != palette_end )
+            return best_entry-palette;
+
+        // TODO(F3): HACK. Need palette traits, and an error function
+        // here. We blatantly assume value_type is a normed linear
+        // space.
+        const value_type* curr_entry( palette );
+        best_entry = curr_entry;
+        while( curr_entry != palette_end )
+        {
+            if( norm(*curr_entry,*best_entry) > norm(*curr_entry,v) )
+                best_entry = curr_entry;
+
+            ++curr_entry;
+        }
+
+        return best_entry-palette;
+    }
+
+    value_type toCol( value_type const& rCol ) const
+    {
+        return rCol;
+    }
+
+public:
+    PaletteImageAccessor() :
+        palette(0),
+        num_entries(0)
+    {}
+
+    PaletteImageAccessor( const value_type* pPalette,
+                          data_type         entries ) :
+        palette(pPalette),
+        num_entries(entries)
+    {}
+
+    template< class Iterator >
+    value_type operator()(Iterator const& i) const { return toCol(palette[i.get()]); }
+    value_type operator()(data_type const* i) const { return toCol(palette[*i]); }
+
+    template< class Iterator, class Difference >
+    value_type operator()(Iterator const& i, Difference const& diff) const
+    {
+        return toCol(palette[i.get(diff)]);
+    }
+
+    template< typename V, class Iterator >
+    void set(V const& value, Iterator const& i) const
+    {
+        i.set(
+            find_best_match(
+                vigra::detail::RequiresExplicitCast<value_type>::cast(value) ));
+    }
+
+    template< typename V, class Iterator, class Difference >
+    void set(V const& value, Iterator const& i, Difference const& diff) const
+    {
+        i.set(
+            find_best_match(
+                vigra::detail::RequiresExplicitCast<value_type>::cast(value)),
+            diff );
+    }
+};
+
+} // namespace basebmp
+
+#endif /* INCLUDED_BASEBMP_PALETTEIMAGEACCESSOR_HXX */
diff --git a/basebmp/inc/basebmp/pixeliterator.hxx b/basebmp/inc/basebmp/pixeliterator.hxx
new file mode 100644
index 000000000000..9f1f3c997ea2
--- /dev/null
+++ b/basebmp/inc/basebmp/pixeliterator.hxx
@@ -0,0 +1,362 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: pixeliterator.hxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: thb $ $Date: 2006-05-31 09:49:43 $
+ *
+ *  The Contents of this file are made available subject to
+ *  the terms of GNU Lesser General Public License Version 2.1.
+ *
+ *
+ *    GNU Lesser General Public License Version 2.1
+ *    =============================================
+ *    Copyright 2005 by Sun Microsystems, Inc.
+ *    901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *    This library is free software; you can redistribute it and/or
+ *    modify it under the terms of the GNU Lesser General Public
+ *    License version 2.1, as published by the Free Software Foundation.
+ *
+ *    This library is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *    Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with this library; if not, write to the Free Software
+ *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *    MA  02111-1307  USA
+ *
+ ************************************************************************/
+
+#ifndef INCLUDED_BASEBMP_PIXELITERATOR_HXX
+#define INCLUDED_BASEBMP_PIXELITERATOR_HXX
+
+#include "metafunctions.hxx"
+#include "stridedarrayiterator.hxx"
+
+#include <boost/static_assert.hpp>
+#include <vigra/metaprogramming.hxx>
+#include <vigra/diff2d.hxx>
+
+namespace basebmp
+{
+
+template< typename Valuetype > class PixelColumnIterator
+{
+public:
+    typedef Valuetype                           value_type;
+    typedef Valuetype&                          reference;
+    typedef Valuetype*                          pointer;
+    typedef int                                 difference_type;
+    typedef image_traverser_tag                 iterator_category;
+
+    typedef StridedArrayIterator< value_type >  MoveY;
+
+private:
+    MoveY           y;
+
+    bool equal( PixelColumnIterator const & rhs ) const
+    {
+        return rhs.y == y;
+    }
+
+    bool less( PixelColumnIterator const & rhs ) const
+    {
+        return y < rhs.y;
+    }
+
+public:
+    PixelColumnIterator() :
+        y(0)
+    {}
+
+    explicit PixelColumnIterator( const MoveY& pos ) :
+        y(pos)
+    {}
+
+    PixelColumnIterator( const MoveY& pos, int x ) :
+        y(pos,x)
+    {}
+
+    PixelColumnIterator& operator+=( difference_type d )
+    {
+        y += d;
+        return *this;
+    }
+
+    PixelColumnIterator& operator-=( difference_type d )
+    {
+        y -= d;
+        return *this;
+    }
+
+    PixelColumnIterator operator+( difference_type d )
+    {
+        PixelColumnIterator res(*this);
+        res += d;
+        return res;
+    }
+
+    PixelColumnIterator operator-( difference_type d )
+    {
+        PixelColumnIterator res(*this);
+        res -= d;
+        return res;
+    }
+
+    PixelColumnIterator& operator++()
+    {
+        ++y;
+        return *this;
+    }
+
+    PixelColumnIterator& operator--()
+    {
+        --y;
+        return *this;
+    }
+
+    PixelColumnIterator operator++(int)
+    {
+        PixelColumnIterator res(*this);
+        ++y;
+        return res;
+    }
+
+    PixelColumnIterator operator--(int)
+    {
+        PixelColumnIterator res(*this);
+        --y;
+        return res;
+    }
+
+    bool operator==(PixelColumnIterator const & rhs) const
+    {
+        return equal( rhs );
+    }
+
+    bool operator!=(PixelColumnIterator const & rhs) const
+    {
+        return !equal( rhs );
+    }
+
+    bool operator<(PixelColumnIterator const & rhs) const
+    {
+        return less(rhs);
+    }
+
+    bool operator<=(PixelColumnIterator const & rhs) const
+    {
+        return !less(rhs);
+    }
+
+    bool operator>(PixelColumnIterator const & rhs) const
+    {
+        return rhs.less(*this);
+    }
+
+    bool operator>=(PixelColumnIterator const & rhs) const
+    {
+        return !rhs.less(*this);
+    }
+
+    difference_type operator-(PixelColumnIterator const & rhs) const
+    {
+        return y - rhs.y;
+    }
+
+    value_type get() const
+    {
+        return *y();
+    }
+
+    value_type get(difference_type d) const
+    {
+        return *y(d);
+    }
+
+    void set( value_type v ) const
+    {
+        *y() = v;
+    }
+
+    void set( value_type v, difference_type d ) const
+    {
+        *y(d) = v;
+    }
+
+    reference operator*() const
+    {
+        return *y();
+    }
+
+    pointer operator->() const
+    {
+        return y();
+    }
+
+    reference operator[](difference_type d) const
+    {
+        return *y(d);
+    }
+
+    reference operator()(int dy) const
+    {
+        return *y(dy);
+    }
+};
+
+template< typename Valuetype > class PixelIterator
+{
+public:
+    typedef Valuetype                          value_type;
+    typedef Valuetype&                         reference;
+    typedef Valuetype*                         pointer;
+    typedef vigra::Diff2D                      difference_type;
+    typedef image_traverser_tag                iterator_category;
+    typedef pointer                            row_iterator;
+    typedef PixelColumnIterator<value_type>    column_iterator;
+
+    typedef int                                MoveX;
+    typedef StridedArrayIterator< value_type > MoveY;
+
+    // TODO(F2): direction of iteration (ImageIterator can be made to
+    // run backwards)
+
+private:
+    bool equal(PixelIterator const & rhs) const
+    {
+        return (x == rhs.x) && (y == rhs.y);
+    }
+
+    pointer current() const
+    {
+        return y() + x;
+    }
+
+    pointer current(int dx, int dy) const
+    {
+        return y(dy) + x+dy;
+    }
+
+public:
+    PixelIterator() :
+        x(0),
+        y(0)
+    {}
+
+    PixelIterator(pointer base, int ystride) :
+        x(0),
+        y(ystride,base)
+    {}
+
+    bool operator==(PixelIterator const & rhs) const
+    {
+        return equal(rhs);
+    }
+
+    bool operator!=(PixelIterator const & rhs) const
+    {
+        return !equal(rhs);
+    }
+
+    difference_type operator-(PixelIterator const & rhs) const
+    {
+        return difference_type(x - rhs.x, y - rhs.y);
+    }
+
+    MoveX x;
+    MoveY y;
+
+    PixelIterator & operator+=(difference_type const & s)
+    {
+        x += s.x;
+        y += s.y;
+        return *this;
+    }
+
+    PixelIterator & operator-=(difference_type const & s)
+    {
+        x -= s.x;
+        y -= s.y;
+        return *this;
+    }
+
+    PixelIterator operator+(difference_type const & s) const
+    {
+        PixelIterator ret(*this);
+        ret += s;
+        return ret;
+    }
+
+    PixelIterator operator-(difference_type const & s) const
+    {
+        PixelIterator ret(*this);
+        ret -= s;
+        return ret;
+    }
+
+    row_iterator rowIterator() const
+    {
+        return row_iterator(y()+x);
+    }
+
+    column_iterator columnIterator() const
+    {
+        return column_iterator(y,x);
+    }
+
+    value_type get() const
+    {
+        return *current();
+    }
+
+    value_type get(difference_type const & d) const
+    {
+        return *current(d.y, d.x);
+    }
+
+    void set( value_type v ) const
+    {
+        *current() = v;
+    }
+
+    void set( value_type v, difference_type const & d ) const
+    {
+        *current(d.y,d.x) = v;
+    }
+
+    reference operator*() const
+    {
+        return *current();
+    }
+
+    pointer operator->() const
+    {
+        return current();
+    }
+
+    reference operator[]( const vigra::Diff2D& d ) const
+    {
+        return *current(d.x,d.y);
+    }
+
+    reference operator()(int dx, int dy) const
+    {
+        return *current(dx,dy);
+    }
+
+    pointer operator[](int dy) const
+    {
+        return y(dy) + x;
+    }
+};
+
+} // namespace basebmp
+
+#endif /* INCLUDED_BASEBMP_PIXELITERATOR_HXX */
diff --git a/basebmp/inc/basebmp/scanlineformats.hxx b/basebmp/inc/basebmp/scanlineformats.hxx
new file mode 100644
index 000000000000..c0aef970c1a8
--- /dev/null
+++ b/basebmp/inc/basebmp/scanlineformats.hxx
@@ -0,0 +1,82 @@
+/*************************************************************************
+ *
+ *  $RCSfile: scanlineformats.hxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: thb $ $Date: 2006-05-31 09:49:43 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *  MA  02111-1307  USA
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (the "License"); You may not use this file
+ *  except in compliance with the License. You may obtain a copy of the
+ *  License at http://www.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+
+#ifndef INCLUDED_BASEBMP_SCANLINEFORMATS_HXX
+#define INCLUDED_BASEBMP_SCANLINEFORMATS_HXX
+
+/* Definition of Scanline formats */
+
+namespace basebmp { namespace Format
+{
+    static const sal_Int32 ONE_BIT_MSB_PAL        = (sal_Int32)0x01;
+    static const sal_Int32 ONE_BIT_LSB_PAL        = (sal_Int32)0x02;
+    static const sal_Int32 TWO_BIT_MSB_PAL        = (sal_Int32)0x03;
+    static const sal_Int32 TWO_BIT_LSB_PAL        = (sal_Int32)0x04;
+    static const sal_Int32 FOUR_BIT_MSB_PAL       = (sal_Int32)0x05;
+    static const sal_Int32 FOUR_BIT_LSB_PAL       = (sal_Int32)0x06;
+    static const sal_Int32 EIGHT_BIT_PAL          = (sal_Int32)0x07;
+    static const sal_Int32 EIGHT_BIT_TC_MASK      = (sal_Int32)0x0A;
+    static const sal_Int32 SIXTEEN_BIT_TC_MASK    = (sal_Int32)0x0B;
+    static const sal_Int32 TWENTYFOUR_BIT_TC_MASK = (sal_Int32)0x0C;
+    static const sal_Int32 THIRTYTWO_BIT_TC_MASK  = (sal_Int32)0x0D;
+} }
+
+#endif /* INCLUDED_BASEBMP_SCANLINEFORMATS_HXX */
diff --git a/basebmp/inc/basebmp/stridedarrayiterator.hxx b/basebmp/inc/basebmp/stridedarrayiterator.hxx
new file mode 100644
index 000000000000..bcff5a21c518
--- /dev/null
+++ b/basebmp/inc/basebmp/stridedarrayiterator.hxx
@@ -0,0 +1,102 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: stridedarrayiterator.hxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: thb $ $Date: 2006-05-31 09:49:43 $
+ *
+ *  The Contents of this file are made available subject to
+ *  the terms of GNU Lesser General Public License Version 2.1.
+ *
+ *
+ *    GNU Lesser General Public License Version 2.1
+ *    =============================================
+ *    Copyright 2005 by Sun Microsystems, Inc.
+ *    901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *    This library is free software; you can redistribute it and/or
+ *    modify it under the terms of the GNU Lesser General Public
+ *    License version 2.1, as published by the Free Software Foundation.
+ *
+ *    This library is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *    Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with this library; if not, write to the Free Software
+ *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *    MA  02111-1307  USA
+ *
+ ************************************************************************/
+
+#ifndef INCLUDED_BASEBMP_STRIDEDARRAYITERATOR_HXX
+#define INCLUDED_BASEBMP_STRIDEDARRAYITERATOR_HXX
+
+namespace basebmp
+{
+
+// changed semantics re. DirectionSelector<StridedArrayTag>: stride
+// now counts in <em>raw</em> bytes!
+template< typename T > class StridedArrayIterator
+{
+public:
+    typedef typename clone_const<T, unsigned char>::type  internal_type;
+
+    StridedArrayIterator(int stride, T* ptr = 0) :
+        stride_(stride),
+        current_(reinterpret_cast<internal_type*>(ptr))
+    {}
+
+    /// Copy from other StridedArrayIterator, plus given offset
+    StridedArrayIterator( StridedArrayIterator const& rSrc,
+                          int                         offset ) :
+        stride_(rSrc.stride_),
+        current_(reinterpret_cast<internal_type*>(
+                     reinterpret_cast<T*>(rSrc.current_)+offset))
+    {}
+
+    void operator++() {current_ += stride_; }
+    void operator++(int) {current_ += stride_; }
+    void operator--() {current_ -= stride_; }
+    void operator--(int) {current_ -= stride_; }
+    void operator+=(int dy) {current_ += dy*stride_; }
+    void operator-=(int dy) {current_ -= dy*stride_; }
+
+    bool operator==(StridedArrayIterator const & rhs) const
+    { return (current_ == rhs.current_); }
+
+    bool operator!=(StridedArrayIterator const & rhs) const
+    { return (current_ != rhs.current_); }
+
+    bool operator<(StridedArrayIterator const & rhs) const
+    { return (current_ < rhs.current_); }
+
+    bool operator<=(StridedArrayIterator const & rhs) const
+    { return (current_ <= rhs.current_); }
+
+    bool operator>(StridedArrayIterator const & rhs) const
+    { return (current_ > rhs.current_); }
+
+    bool operator>=(StridedArrayIterator const & rhs) const
+    { return (current_ >= rhs.current_); }
+
+    int operator-(StridedArrayIterator const & rhs) const
+    { return (current_ - rhs.current_) / stride_; }
+
+    T* operator()() const
+    { return reinterpret_cast<T*>(current_); }
+
+    T* operator()(int d) const
+    { return reinterpret_cast<T*>(current_ + d*stride_); }
+
+    int            stride_;
+    internal_type* current_;
+};
+
+} // namespace basebmp
+
+#endif /* INCLUDED_BASEBMP_STRIDEDARRAYITERATOR_HXX */
diff --git a/basebmp/prj/build.lst b/basebmp/prj/build.lst
new file mode 100644
index 000000000000..36813ae257d8
--- /dev/null
+++ b/basebmp/prj/build.lst
@@ -0,0 +1,4 @@
+bx	basebmp	:	sal vigra basegfx boost NULL
+bx	basebmp									usr1	-	all	bx_mkout NULL
+bx	basebmp\source							nmake	-	all	bx_source NULL
+bx	basebmp\util							nmake	-	all	bx_util bx_source NULL
diff --git a/basebmp/prj/d.lst b/basebmp/prj/d.lst
new file mode 100644
index 000000000000..03cfbcd3fe25
--- /dev/null
+++ b/basebmp/prj/d.lst
@@ -0,0 +1,10 @@
+..\%__SRC%\lib\ibasebmp.lib %_DEST%\lib%_EXT%\ibasebmp.lib
+
+..\%__SRC%\bin\basebmp?????.dll %_DEST%\bin%_EXT%\basebmp?????.dll
+
+..\%__SRC%\lib\libbasebmp?????.* %_DEST%\lib%_EXT%\libbasebmp?????.*
+..\%__SRC%\lib\*.a %_DEST%\lib%_EXT%\*.a
+..\%__SRC%\lib\*.dylib %_DEST%\lib%_EXT%\*.dylib
+
+mkdir: %_DEST%\inc%_EXT%\basebmp
+..\inc\basebmp\*.hxx %_DEST%\inc%_EXT%\basebmp\*.hxx
diff --git a/basebmp/source/bitmapdevice.cxx b/basebmp/source/bitmapdevice.cxx
new file mode 100644
index 000000000000..3ee33010f2b2
--- /dev/null
+++ b/basebmp/source/bitmapdevice.cxx
@@ -0,0 +1,1023 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: bitmapdevice.cxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: thb $ $Date: 2006-05-31 09:49:44 $
+ *
+ *  The Contents of this file are made available subject to
+ *  the terms of GNU Lesser General Public License Version 2.1.
+ *
+ *
+ *    GNU Lesser General Public License Version 2.1
+ *    =============================================
+ *    Copyright 2005 by Sun Microsystems, Inc.
+ *    901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *    This library is free software; you can redistribute it and/or
+ *    modify it under the terms of the GNU Lesser General Public
+ *    License version 2.1, as published by the Free Software Foundation.
+ *
+ *    This library is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *    Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with this library; if not, write to the Free Software
+ *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *    MA  02111-1307  USA
+ *
+ ************************************************************************/
+
+#include "basebmp/bitmapdevice.hxx"
+#include "basebmp/packedpixeliterator.hxx"
+#include "basebmp/pixeliterator.hxx"
+#include "basebmp/paletteimageaccessor.hxx"
+#include "basebmp/color.hxx"
+#include "basebmp/accessor.hxx"
+#include "basebmp/accessoradapters.hxx"
+#include "basebmp/scanlineformats.hxx"
+#include "basebmp/linerenderer.hxx"
+
+#include <rtl/alloc.h>
+#include <rtl/memory.h>
+#include <osl/diagnose.h>
+
+#include <basegfx/tools/tools.hxx>
+#include <basegfx/range/b2irange.hxx>
+#include <basegfx/range/b2drange.hxx>
+#include <basegfx/polygon/b2dpolygon.hxx>
+#include <basegfx/polygon/b2dpolygontools.hxx>
+#include <basegfx/polygon/b2dpolygonclipper.hxx>
+#include <basegfx/polygon/b2dpolypolygonrasterconverter.hxx>
+#include <basegfx/point/b2ipoint.hxx>
+#include <basegfx/vector/b2ivector.hxx>
+
+#include <vigra/basicimage.hxx>
+#include <vigra/imageiterator.hxx>
+
+
+namespace basebmp
+{
+
+namespace
+{
+    typedef PackedPixelIterator< sal_uInt8,
+                                 sal_uInt8,
+                                 1,
+                                 true >          MaskIterator;
+    typedef StandardAccessor< sal_uInt8 >        MaskAccessor;
+
+    typedef vigra::ImageIterator< sal_uInt8 >                    AlphaMaskIterator;
+    typedef vigra::AccessorTraits< sal_uInt8 >::default_accessor AlphaMaskAccessor;
+
+
+    template< class DestIterator, class DestAccessor > class Renderer :
+        public basegfx::B2DPolyPolygonRasterConverter
+    {
+    private:
+        basegfx::B2IRange                 bounds_;
+        typename DestIterator::value_type fillColor_;
+        typename DestIterator::value_type clearColor_;
+        DestIterator                      begin_;
+        DestAccessor                      accessor_;
+
+    public:
+        Renderer(const basegfx::B2DPolyPolygon&     rPolyPolyRaster,
+                 typename DestIterator::value_type  fillColor,
+                 const basegfx::B2IRange&           bounds,
+                 DestIterator                       begin,
+                 DestIterator                       end,
+                 DestAccessor                       accessor ) :
+            B2DPolyPolygonRasterConverter(rPolyPolyRaster,
+                                          basegfx::B2DRange(bounds) ),
+            bounds_(bounds),
+            fillColor_( fillColor ),
+            begin_( begin ),
+            accessor_( accessor )
+        {
+        }
+
+        virtual void span(const double& rfXLeft,
+                          const double& rfXRight,
+                          sal_Int32     nY,
+                          bool          bOn )
+        {
+            if( !bOn ||
+                nY < bounds_.getMinY() ||
+                nY >= bounds_.getMaxY() ||
+                rfXLeft >= bounds_.getMaxX() ||
+                rfXRight < bounds_.getMinX() )
+            {
+                return;
+            }
+
+            // clip span to bitmap bounds
+            const sal_Int32 nStartX( std::max( bounds_.getMinX(),
+                                               std::min( bounds_.getMaxX()-1,
+                                                         basegfx::fround( rfXLeft ))));
+            const sal_Int32 nEndX  ( std::max( bounds_.getMinX(),
+                                               std::min( bounds_.getMaxX()-1,
+                                                         basegfx::fround( rfXRight ))));
+
+            DestIterator currIter( begin_ + vigra::Diff2D(0,nY) );
+            typename DestIterator::row_iterator rowIter( currIter.rowIterator() + nStartX);
+            typename DestIterator::row_iterator rowEnd( currIter.rowIterator() + nEndX );
+
+            // TODO(P2): Provide specialized span fill methods on the
+            // iterator/accessor
+            while( rowIter != rowEnd )
+                accessor_.set(fillColor_, rowIter++);
+        }
+    };
+
+    template< class DestIterator, class DestAccessor >
+    std::auto_ptr< Renderer< DestIterator, DestAccessor > > makeRenderer(
+        const basegfx::B2DPolyPolygon&                          rPolyPolyRaster,
+        typename DestIterator::value_type                       fillColor,
+        const basegfx::B2IRange&                                outRange,
+        vigra::triple<DestIterator, DestIterator, DestAccessor> dest )
+    {
+        basegfx::B2IRange aBmpRange(0,0,
+                                    dest.second.x - dest.first.x,
+                                    dest.second.y - dest.first.y );
+        aBmpRange.intersect( outRange );
+
+        return std::auto_ptr< Renderer< DestIterator, DestAccessor > >(
+            new Renderer< DestIterator, DestAccessor >(rPolyPolyRaster,
+                                                       fillColor,
+                                                       aBmpRange,
+                                                       dest.first,
+                                                       dest.second,
+                                                       dest.third));
+    }
+
+    template< class DestIterator, class DestAccessor > class BitmapRenderer : public BitmapDevice
+    {
+    public:
+        typedef BitmapRenderer<MaskIterator,
+                               MaskAccessor>                MaskBitmap;
+        typedef BitmapRenderer<AlphaMaskIterator,
+                               AlphaMaskAccessor>           AlphaMaskBitmap;
+        typedef typename xorAccessor<DestAccessor>::type    XorAccessor;
+        typedef typename maskedAccessor<DestAccessor,
+                                        MaskAccessor,
+                                        DestIterator,
+                                        MaskIterator>::type MaskedAccessor;
+        typedef typename maskedAccessor<XorAccessor,
+                                        MaskAccessor,
+                                        DestIterator,
+                                        MaskIterator>::type MaskedXorAccessor;
+
+        DestIterator      maBegin;
+        DestIterator      maEnd;
+        DestAccessor      maAccessor;
+        XorAccessor       maXorAccessor;
+        MaskedAccessor    maMaskedAccessor;
+        MaskedXorAccessor maMaskedXorAccessor;
+        int               mnWidth;
+        int               mnHeight;
+
+        BitmapRenderer( const basegfx::B2IVector& rSize,
+                        bool                      bTopDown,
+                        sal_Int32                 nScanlineFormat,
+                        sal_Int32                 nScanlineStride,
+                        DestIterator              begin,
+                        DestIterator              end,
+                        DestAccessor              accessor,
+                        const RawMemorySharedPtr& rMem ) :
+            BitmapDevice( rSize, bTopDown, nScanlineFormat, nScanlineStride, rMem ),
+            maBegin( begin ),
+            maEnd( end ),
+            maAccessor( accessor ),
+            maXorAccessor( accessor ),
+            maMaskedAccessor( accessor ),
+            maMaskedXorAccessor( maXorAccessor ),
+            mnWidth( maEnd.x - maBegin.x ),
+            mnHeight( maEnd.y - maBegin.y )
+        {}
+
+    private:
+        boost::shared_ptr<BitmapRenderer> getCompatibleBitmap( const BitmapDeviceSharedPtr& bmp ) const
+        {
+            return boost::dynamic_pointer_cast< BitmapRenderer >( bmp );
+        }
+
+        virtual bool isCompatibleBitmap( const BitmapDeviceSharedPtr& bmp ) const
+        {
+            // TODO(P1): dynamic_cast usually called twice for
+            // compatible formats
+            return getCompatibleBitmap(bmp).get() != NULL;
+        }
+
+        boost::shared_ptr<MaskBitmap> getCompatibleMask( const BitmapDeviceSharedPtr& bmp ) const
+        {
+            return boost::dynamic_pointer_cast<MaskBitmap>( bmp );
+        }
+
+        virtual bool isCompatibleClipMask( const BitmapDeviceSharedPtr& bmp ) const
+        {
+            // TODO(P1): dynamic_cast usually called twice for
+            // compatible formats
+            return getCompatibleMask( bmp ).get() != NULL;
+        }
+
+        boost::shared_ptr<AlphaMaskBitmap> getCompatibleAlphaMask( const BitmapDeviceSharedPtr& bmp ) const
+        {
+            return boost::dynamic_pointer_cast<AlphaMaskBitmap>( bmp );
+        }
+
+        virtual bool isCompatibleAlphaMask( const BitmapDeviceSharedPtr& bmp ) const
+        {
+            // TODO(P1): dynamic_cast usually called twice for
+            // compatible formats
+            return getCompatibleAlphaMask( bmp ).get() != NULL;
+        }
+
+        virtual const Color* getPalette_i() const
+        {
+            // TODO(F3): Palette
+            return NULL;
+        }
+
+        virtual const sal_Int32 getPaletteEntryCount_i() const
+        {
+            // TODO(F3): Palette
+            return 0;
+        }
+
+        virtual void clear_i( Color fillColor )
+        {
+            DestIterator currIter( maBegin );
+            const DestIterator endIter( maBegin + vigra::Diff2D(0,mnHeight) );
+            while( currIter != endIter )
+            {
+                typename DestIterator::row_iterator rowIter( currIter.rowIterator() );
+                const typename DestIterator::row_iterator rowEnd( rowIter + mnWidth );
+
+                // TODO(P2): Provide specialized span fill methods on the
+                // iterator/accessor
+                while( rowIter != rowEnd )
+                    maAccessor.set(fillColor, rowIter++);
+
+                currIter += vigra::Diff2D( 0,1 );
+            }
+        }
+
+        virtual void setPixel_i( const basegfx::B2IPoint& rPt,
+                                 Color                    lineColor,
+                                 DrawMode                 drawMode )
+        {
+            const DestIterator pixel( maBegin +
+                                      vigra::Diff2D(rPt.getX(),
+                                                    rPt.getY()) );
+            if( drawMode == DrawMode_XOR )
+                maXorAccessor.set( lineColor, pixel );
+            else
+                maAccessor.set( lineColor, pixel );
+        }
+
+        virtual void setPixel_i( const basegfx::B2IPoint&     rPt,
+                                 Color                        lineColor,
+                                 DrawMode                     drawMode,
+                                 const BitmapDeviceSharedPtr& rClip )
+        {
+            boost::shared_ptr<MaskBitmap> pMask( getCompatibleMask(rClip) );
+
+            const vigra::Diff2D offset(rPt.getX(),
+                                       rPt.getY());
+
+            const DestIterator pixel( maBegin + offset );
+            const MaskIterator maskPixel( pMask->maBegin + offset );
+
+            if( drawMode == DrawMode_XOR )
+                maMaskedXorAccessor.set( lineColor, pixel, maskPixel );
+            else
+                maMaskedAccessor.set( lineColor, pixel, maskPixel );
+        }
+
+        virtual Color getPixel_i(const basegfx::B2IPoint& rPt )
+        {
+            const DestIterator pixel( maBegin +
+                                      vigra::Diff2D(rPt.getX(),
+                                                    rPt.getY()) );
+            return maAccessor(pixel);
+        }
+
+        virtual void drawLine_i(const basegfx::B2DPoint& rPt1,
+                                const basegfx::B2DPoint& rPt2,
+                                Color                    lineColor,
+                                DrawMode                 drawMode )
+        {
+            renderLine( basegfx::fround(rPt1),
+                        basegfx::fround(rPt2),
+                        lineColor,
+                        maBegin,
+                        maEnd,
+                        maAccessor );
+        }
+
+        virtual void drawLine_i(const basegfx::B2DPoint&     rPt1,
+                                const basegfx::B2DPoint&     rPt2,
+                                Color                        lineColor,
+                                DrawMode                     drawMode,
+                                const BitmapDeviceSharedPtr& rClip )
+        {
+            OSL_ENSURE( false, "drawLine_i(): Clipped output not yet implemented!" );
+        }
+
+        virtual void drawPolygon_i(const basegfx::B2DPolygon& rPoly,
+                                   Color                      lineColor,
+                                   DrawMode                   drawMode )
+        {
+            const sal_uInt32 nVertices( rPoly.count() );
+            for( sal_uInt32 i=1; i<nVertices; ++i )
+            {
+                renderLine( basegfx::fround(rPoly.getB2DPoint(i-1)),
+                            basegfx::fround(rPoly.getB2DPoint(i)),
+                            lineColor,
+                            maBegin,
+                            maEnd,
+                            maAccessor );
+            }
+
+            if( nVertices > 1 && rPoly.isClosed() )
+                renderLine( basegfx::fround(rPoly.getB2DPoint(nVertices-1)),
+                            basegfx::fround(rPoly.getB2DPoint(0)),
+                            lineColor,
+                            maBegin,
+                            maEnd,
+                            maAccessor );
+        }
+
+        virtual void drawPolygon_i(const basegfx::B2DPolygon&   rPoly,
+                                   Color                        lineColor,
+                                   DrawMode                     drawMode,
+                                   const BitmapDeviceSharedPtr& rClip )
+        {
+            OSL_ENSURE( false, "drawPolygon_i(): clipped output not yet implemented!" );
+        }
+
+        virtual void fillPolyPolygon_i(const basegfx::B2DPolyPolygon& rPoly,
+                                       Color                          fillColor,
+                                       DrawMode                       drawMode,
+                                       const basegfx::B2IRange&       rBounds )
+        {
+/*
+            if( drawMode == DrawMode_XOR )
+                makeRenderer( rPoly,
+                              fillColor,
+                              rBounds,
+                              maBegin,
+                              maEnd,
+                              maXorAccessor )->rasterConvert(
+                                  basegfx::FillRule_NONZERO_WINDING_NUMBER );
+            else
+*/
+                makeRenderer( rPoly,
+                              fillColor,
+                              rBounds,
+                              vigra::make_triple(
+                                  maBegin,
+                                  maEnd,
+                                  maAccessor) )->rasterConvert(
+                                  basegfx::FillRule_NONZERO_WINDING_NUMBER );
+        }
+
+        virtual void fillPolyPolygon_i(const basegfx::B2DPolyPolygon& rPoly,
+                                       Color                          fillColor,
+                                       DrawMode                       drawMode,
+                                       const basegfx::B2IRange&       rBounds,
+                                       const BitmapDeviceSharedPtr&   rClip )
+        {
+            OSL_ENSURE( false, "fillPolyPolygon_i(): Clipped output not yet implemented!" );
+/*          Need uniform accessor for both plain and masked output. Combine
+            mask and bitmap iterator into proxy iterator, and pass that one
+            to the render method
+
+            if( drawMode == DrawMode_XOR )
+                makeRenderer( rPoly,
+                              fillColor,
+                              rBounds,
+                              maBegin,
+                              maEnd,
+                              maMaskedXorAccessor )->rasterConvert(
+                                  basegfx::FillRule_NONZERO_WINDING_NUMBER );
+            else
+                makeRenderer( rPoly,
+                              fillColor,
+                              rBounds,
+                              maBegin,
+                              maEnd,
+                              maMaskedAccessor )->rasterConvert(
+                                  basegfx::FillRule_NONZERO_WINDING_NUMBER );
+*/
+        }
+
+        // must work with *this == rSrcBitmap!
+        virtual void drawBitmap_i(const BitmapDeviceSharedPtr& rSrcBitmap,
+                                  const basegfx::B2IRange&     rSrcRect,
+                                  const basegfx::B2IRange&     rDstRect,
+                                  DrawMode                     drawMode )
+        {
+            OSL_ENSURE( false, "Method not yet implemented!" );
+        }
+
+        virtual void drawBitmap_i(const BitmapDeviceSharedPtr& rSrcBitmap,
+                                  const basegfx::B2IRange&     rSrcRect,
+                                  const basegfx::B2IRange&     rDstRect,
+                                  DrawMode                     drawMode,
+                                  const BitmapDeviceSharedPtr& rClip )
+        {
+            OSL_ENSURE( false, "Method not yet implemented!" );
+        }
+
+        // must work with *this == rSrcBitmap!
+        virtual void drawMaskedColor_i(Color                        rSrcColor,
+                                       const BitmapDeviceSharedPtr& rAlphaMask,
+                                       const basegfx::B2IRange&     rSrcRect,
+                                       const basegfx::B2IPoint&     rDstPoint )
+        {
+            OSL_ENSURE( false, "Method not yet implemented!" );
+        }
+
+        virtual void drawMaskedColor_i(Color                        rSrcColor,
+                                       const BitmapDeviceSharedPtr& rAlphaMask,
+                                       const basegfx::B2IRange&     rSrcRect,
+                                       const basegfx::B2IPoint&     rDstPoint,
+                                       const BitmapDeviceSharedPtr& rClip )
+         {
+            OSL_ENSURE( false, "Method not yet implemented!" );
+        }
+
+        // must work with *this == rSrcBitmap!
+        virtual void drawMaskedBitmap_i(const BitmapDeviceSharedPtr& rSrcBitmap,
+                                        const BitmapDeviceSharedPtr& rMask,
+                                        const basegfx::B2IRange&     rSrcRect,
+                                        const basegfx::B2IRange&     rDstRect,
+                                        DrawMode                     drawMode )
+        {
+            OSL_ENSURE( false, "Method not yet implemented!" );
+        }
+
+        virtual void drawMaskedBitmap_i(const BitmapDeviceSharedPtr& rSrcBitmap,
+                                        const BitmapDeviceSharedPtr& rMask,
+                                        const basegfx::B2IRange&     rSrcRect,
+                                        const basegfx::B2IRange&     rDstRect,
+                                        DrawMode                     drawMode,
+                                        const
+
+ BitmapDeviceSharedPtr& rClip )
+        {
+            OSL_ENSURE( false, "Method not yet implemented!" );
+        }
+    };
+} // namespace
+
+struct ImplBitmapDevice
+{
+    /// Bitmap memory plus deleter
+    RawMemorySharedPtr mpMem;
+
+    basegfx::B2IRange  maBounds;
+    basegfx::B2DRange  maFloatBounds;
+    sal_Int32          mnScanlineFormat;
+    sal_Int32          mnScanlineStride;
+};
+
+
+BitmapDevice::BitmapDevice( const basegfx::B2IVector& rSize,
+                            bool                      bTopDown,
+                            sal_Int32                 nScanlineFormat,
+                            sal_Int32                 nScanlineStride,
+                            const RawMemorySharedPtr& rMem ) :
+    mpImpl( new ImplBitmapDevice )
+{
+    mpImpl->mpMem = rMem;
+    mpImpl->maBounds = basegfx::B2IRange( 0,0,rSize.getX(),rSize.getY() );
+    mpImpl->maFloatBounds = basegfx::B2DRange( 0,0,rSize.getX(),rSize.getY() );
+    mpImpl->mnScanlineFormat = nScanlineFormat;
+    mpImpl->mnScanlineStride = bTopDown ? nScanlineStride : -nScanlineStride;
+}
+
+BitmapDevice::~BitmapDevice()
+{
+    // outline, because of internal ImplBitmapDevice
+}
+
+basegfx::B2IVector BitmapDevice::getSize() const
+{
+    return basegfx::B2IVector( mpImpl->maBounds.getWidth(),
+                               mpImpl->maBounds.getHeight() );
+}
+
+bool BitmapDevice::isTopDown() const
+{
+    return mpImpl->mnScanlineStride >= 0;
+}
+
+sal_Int32 BitmapDevice::getScanlineFormat() const
+{
+    return mpImpl->mnScanlineFormat;
+}
+
+sal_Int32 BitmapDevice::getScanlineStride() const
+{
+    return mpImpl->mnScanlineStride;
+}
+
+RawMemorySharedPtr BitmapDevice::getBuffer() const
+{
+    return mpImpl->mpMem;
+}
+
+const Color* BitmapDevice::getPalette() const
+{
+    return getPalette_i();
+}
+
+const sal_Int32 BitmapDevice::getPaletteEntryCount() const
+{
+    return getPaletteEntryCount_i();
+}
+
+void BitmapDevice::clear( Color fillColor )
+{
+    clear_i( fillColor );
+}
+
+void BitmapDevice::setPixel( const basegfx::B2IPoint& rPt,
+                             Color                    lineColor,
+                             DrawMode                 drawMode )
+{
+    if( mpImpl->maBounds.isInside(rPt) )
+        setPixel_i(rPt,lineColor,drawMode);
+}
+
+void BitmapDevice::setPixel( const basegfx::B2IPoint&     rPt,
+                             Color                        lineColor,
+                             DrawMode                     drawMode,
+                             const BitmapDeviceSharedPtr& rClip )
+{
+    if( mpImpl->maBounds.isInside(rPt) )
+    {
+        if( isCompatibleClipMask( rClip ) )
+            setPixel_i(rPt,lineColor,drawMode,rClip);
+        else
+            OSL_ENSURE( false, "Generic output not yet implemented!" );
+    }
+}
+
+Color BitmapDevice::getPixel( const basegfx::B2IPoint& rPt )
+{
+    if( mpImpl->maBounds.isInside(rPt) )
+        return getPixel_i(rPt);
+
+    return Color();
+}
+
+void BitmapDevice::drawLine( const basegfx::B2IPoint& rPt1,
+                             const basegfx::B2IPoint& rPt2,
+                             Color                    lineColor,
+                             DrawMode                 drawMode )
+{
+    basegfx::B2DPoint aPt1( rPt1 );
+    basegfx::B2DPoint aPt2( rPt2 );
+
+    if( basegfx::tools::liangBarskyClip2D(aPt1,aPt2,mpImpl->maFloatBounds) )
+        drawLine_i( aPt1, aPt2,
+                    lineColor,
+                    drawMode );
+}
+
+void BitmapDevice::drawLine( const basegfx::B2IPoint&     rPt1,
+                             const basegfx::B2IPoint&     rPt2,
+                             Color                        lineColor,
+                             DrawMode                     drawMode,
+                             const BitmapDeviceSharedPtr& rClip )
+{
+#if 1
+    drawLine( rPt1, rPt2, lineColor, drawMode );
+#else
+    basegfx::B2DPoint aPt1( rPt1 );
+    basegfx::B2DPoint aPt2( rPt2 );
+
+    if( basegfx::tools::liangBarskyClip2D(aPt1,aPt2,mpImpl->maFloatBounds) )
+    {
+        if( isCompatibleClipMask( rClip ) )
+            drawLine_i( aPt1, aPt2,
+                        lineColor,
+                        drawMode,
+                        rClip );
+        else
+            OSL_ENSURE( false, "Generic output not yet implemented!" );
+    }
+#endif
+}
+
+void BitmapDevice::drawPolygon( const basegfx::B2DPolygon& rPoly,
+                                Color                      lineColor,
+                                DrawMode                   drawMode )
+{
+    basegfx::B2DPolyPolygon aPoly(
+        basegfx::tools::clipPolygonOnRange( rPoly,
+                                            mpImpl->maFloatBounds,
+                                            true,
+                                            true ));
+    const sal_uInt32 numPolies( aPoly.count() );
+    for( sal_uInt32 i=0; i<numPolies; ++i )
+        if( aPoly.getB2DPolygon(i).count() )
+            drawPolygon_i( aPoly.getB2DPolygon(i), lineColor, drawMode );
+}
+
+void BitmapDevice::drawPolygon( const basegfx::B2DPolygon&   rPoly,
+                                Color                        lineColor,
+                                DrawMode                     drawMode,
+                                const BitmapDeviceSharedPtr& rClip )
+{
+#if 1
+    drawPolygon( rPoly, lineColor, drawMode );
+#else
+    basegfx::B2DPolyPolygon aPoly(
+        basegfx::tools::clipPolygonOnRange( rPoly,
+                                            mpImpl->maFloatBounds,
+                                            true,
+                                            true ));
+    const sal_uInt32 numPolies( aPoly.count() );
+    for( sal_uInt32 i=0; i<numPolies; ++i )
+        if( aPoly.getB2DPolygon(i).count() )
+            if( isCompatibleClipMask( rClip ) )
+                drawPolygon_i( aPoly.getB2DPolygon(i), lineColor, drawMode, rClip );
+            else
+                OSL_ENSURE( false, "Generic output not yet implemented!" );
+#endif
+}
+
+void BitmapDevice::fillPolyPolygon( const basegfx::B2DPolyPolygon& rPoly,
+                                    Color                          fillColor,
+                                    DrawMode                       drawMode )
+{
+    fillPolyPolygon_i( rPoly, fillColor, drawMode, mpImpl->maBounds );
+}
+
+void BitmapDevice::fillPolyPolygon( const basegfx::B2DPolyPolygon& rPoly,
+                                    Color                          fillColor,
+                                    DrawMode                       drawMode,
+                                    const BitmapDeviceSharedPtr&   rClip )
+{
+#if 1
+    fillPolyPolygon( rPoly, fillColor, drawMode );
+#else
+    if( isCompatibleClipMask( rClip ) )
+        fillPolyPolygon_i( rPoly, fillColor, drawMode, mpImpl->maBounds, rClip );
+    else
+        OSL_ENSURE( false, "Generic output not yet implemented!" );
+#endif
+}
+
+
+namespace
+{
+    // TODO(Q3): Move canvas/canvastools.hxx clipBlit() down
+    // to basegfx, and use here!
+    bool clipAreaImpl( ::basegfx::B2IRange*       o_pDestArea,
+                       ::basegfx::B2IRange&       io_rSourceArea,
+                       ::basegfx::B2IPoint&       io_rDestPoint,
+                       const ::basegfx::B2IRange& rSourceBounds,
+                       const ::basegfx::B2IRange& rDestBounds )
+    {
+        const ::basegfx::B2IPoint aSourceTopLeft(
+            io_rSourceArea.getMinimum() );
+
+        ::basegfx::B2IRange aLocalSourceArea( io_rSourceArea );
+
+        // clip source area (which must be inside rSourceBounds)
+        aLocalSourceArea.intersect( rSourceBounds );
+
+        if( aLocalSourceArea.isEmpty() )
+            return false;
+
+        // calc relative new source area points (relative to orig
+        // source area)
+        const ::basegfx::B2IVector aUpperLeftOffset(
+            aLocalSourceArea.getMinimum()-aSourceTopLeft );
+        const ::basegfx::B2IVector aLowerRightOffset(
+            aLocalSourceArea.getMaximum()-aSourceTopLeft );
+
+        ::basegfx::B2IRange aLocalDestArea( io_rDestPoint + aUpperLeftOffset,
+                                            io_rDestPoint + aLowerRightOffset );
+
+        // clip dest area (which must be inside rDestBounds)
+        aLocalDestArea.intersect( rDestBounds );
+
+        if( aLocalDestArea.isEmpty() )
+            return false;
+
+        // calc relative new dest area points (relative to orig
+        // source area)
+        const ::basegfx::B2IVector aDestUpperLeftOffset(
+            aLocalDestArea.getMinimum()-io_rDestPoint );
+        const ::basegfx::B2IVector aDestLowerRightOffset(
+            aLocalDestArea.getMaximum()-io_rDestPoint );
+
+        io_rSourceArea = ::basegfx::B2IRange( aSourceTopLeft + aDestUpperLeftOffset,
+                                              aSourceTopLeft + aDestLowerRightOffset );
+        io_rDestPoint  = aLocalDestArea.getMinimum();
+
+        if( o_pDestArea )
+            *o_pDestArea = aLocalDestArea;
+
+        return true;
+    }
+}
+
+void BitmapDevice::drawBitmap( const BitmapDeviceSharedPtr& rSrcBitmap,
+                               const basegfx::B2IRange&     rSrcRect,
+                               const basegfx::B2IRange&     rDstRect,
+                               DrawMode                     drawMode )
+{
+    const basegfx::B2IVector& rSrcSize( rSrcBitmap->getSize() );
+    const basegfx::B2IRange   aSrcBounds( 0,0,rSrcSize.getX(),rSrcSize.getY() );
+
+    basegfx::B2IRange aSrcRange( rSrcRect );
+    basegfx::B2IPoint aDestPoint( rDstRect.getMinimum() );
+    basegfx::B2IRange aDestRange;
+
+    // TODO(F2): Scaling/shrinking
+    if( clipAreaImpl( &aDestRange,
+                      aSrcRange,
+                      aDestPoint,
+                      aSrcBounds,
+                      mpImpl->maBounds ))
+    {
+        if( isCompatibleBitmap( rSrcBitmap ) )
+            drawBitmap_i( rSrcBitmap, aSrcRange, aDestRange, drawMode );
+        else
+            OSL_ENSURE( false, "Generic output not yet implemented!" );
+    }
+}
+
+void BitmapDevice::drawBitmap( const BitmapDeviceSharedPtr& rSrcBitmap,
+                               const basegfx::B2IRange&     rSrcRect,
+                               const basegfx::B2IRange&     rDstRect,
+                               DrawMode                     drawMode,
+                               const BitmapDeviceSharedPtr& rClip )
+{
+    const basegfx::B2IVector& rSrcSize( rSrcBitmap->getSize() );
+    const basegfx::B2IRange   aSrcBounds( 0,0,rSrcSize.getX(),rSrcSize.getY() );
+
+    basegfx::B2IRange aSrcRange( rSrcRect );
+    basegfx::B2IPoint aDestPoint( rDstRect.getMinimum() );
+    basegfx::B2IRange aDestRange;
+
+    // TODO(F2): Scaling/shrinking
+    if( clipAreaImpl( &aDestRange,
+                      aSrcRange,
+                      aDestPoint,
+                      aSrcBounds,
+                      mpImpl->maBounds ))
+    {
+        if( isCompatibleBitmap( rSrcBitmap ) &&
+            isCompatibleClipMask( rClip ) )
+        {
+            drawBitmap_i( rSrcBitmap, aSrcRange, aDestRange, drawMode, rClip );
+        }
+        else
+        {
+            OSL_ENSURE( false, "Generic output not yet implemented!" );
+        }
+    }
+}
+
+void BitmapDevice::drawMaskedColor( Color                        rSrcColor,
+                                    const BitmapDeviceSharedPtr& rAlphaMask,
+                                    const basegfx::B2IRange&     rSrcRect,
+                                    const basegfx::B2IPoint&     rDstPoint )
+{
+    const basegfx::B2IVector& rSrcSize( rAlphaMask->getSize() );
+    const basegfx::B2IRange   aSrcBounds( 0,0,rSrcSize.getX(),rSrcSize.getY() );
+
+    basegfx::B2IRange aSrcRange( rSrcRect );
+    basegfx::B2IPoint aDestPoint( rDstPoint );
+
+    if( clipAreaImpl( NULL,
+                      aSrcRange,
+                      aDestPoint,
+                      aSrcBounds,
+                      mpImpl->maBounds ))
+    {
+        if( isCompatibleAlphaMask( rAlphaMask ) )
+            drawMaskedColor_i( rSrcColor, rAlphaMask, aSrcRange, aDestPoint );
+        else
+            OSL_ENSURE( false, "Generic output not yet implemented!" );
+    }
+}
+
+void BitmapDevice::drawMaskedColor( Color                        rSrcColor,
+                                    const BitmapDeviceSharedPtr& rAlphaMask,
+                                    const basegfx::B2IRange&     rSrcRect,
+                                    const basegfx::B2IPoint&     rDstPoint,
+                                    const BitmapDeviceSharedPtr& rClip )
+{
+    const basegfx::B2IVector& rSrcSize( rAlphaMask->getSize() );
+    const basegfx::B2IRange   aSrcBounds( 0,0,rSrcSize.getX(),rSrcSize.getY() );
+
+    basegfx::B2IRange aSrcRange( rSrcRect );
+    basegfx::B2IPoint aDestPoint( rDstPoint );
+
+    if( clipAreaImpl( NULL,
+                      aSrcRange,
+                      aDestPoint,
+                      aSrcBounds,
+                      mpImpl->maBounds ))
+    {
+        if( isCompatibleAlphaMask( rAlphaMask ) &&
+            isCompatibleClipMask( rClip ) )
+        {
+            drawMaskedColor_i( rSrcColor, rAlphaMask, aSrcRange, aDestPoint, rClip );
+        }
+        else
+        {
+            OSL_ENSURE( false, "Generic output not yet implemented!" );
+        }
+    }
+}
+
+void BitmapDevice::drawMaskedBitmap( const BitmapDeviceSharedPtr& rSrcBitmap,
+                                     const BitmapDeviceSharedPtr& rMask,
+                                     const basegfx::B2IRange&     rSrcRect,
+                                     const basegfx::B2IRange&     rDstRect,
+                                     DrawMode                     drawMode )
+{
+    OSL_ASSERT( rMask->getSize() == rSrcBitmap->getSize() );
+
+    const basegfx::B2IVector& rSrcSize( rSrcBitmap->getSize() );
+    const basegfx::B2IRange   aSrcBounds( 0,0,rSrcSize.getX(),rSrcSize.getY() );
+
+    basegfx::B2IRange aSrcRange( rSrcRect );
+    basegfx::B2IPoint aDestPoint( rDstRect.getMinimum() );
+    basegfx::B2IRange aDestRange;
+
+    // TODO(F2): Scaling/shrinking
+    if( clipAreaImpl( &aDestRange,
+                      aSrcRange,
+                      aDestPoint,
+                      aSrcBounds,
+                      mpImpl->maBounds ))
+    {
+        if( isCompatibleBitmap( rSrcBitmap ) &&
+            isCompatibleClipMask( rMask ) )
+        {
+            drawMaskedBitmap_i( rSrcBitmap, rMask, aSrcRange, aDestRange, drawMode );
+        }
+        else
+        {
+            OSL_ENSURE( false, "Generic output not yet implemented!" );
+        }
+    }
+}
+
+void BitmapDevice::drawMaskedBitmap( const BitmapDeviceSharedPtr& rSrcBitmap,
+                                     const BitmapDeviceSharedPtr& rMask,
+                                     const basegfx::B2IRange&     rSrcRect,
+                                     const basegfx::B2IRange&     rDstRect,
+                                     DrawMode                     drawMode,
+                                     const BitmapDeviceSharedPtr& rClip )
+{
+    OSL_ASSERT( rMask->getSize() == rSrcBitmap->getSize() );
+
+    const basegfx::B2IVector& rSrcSize( rSrcBitmap->getSize() );
+    const basegfx::B2IRange   aSrcBounds( 0,0,rSrcSize.getX(),rSrcSize.getY() );
+
+    basegfx::B2IRange aSrcRange( rSrcRect );
+    basegfx::B2IPoint aDestPoint( rDstRect.getMinimum() );
+    basegfx::B2IRange aDestRange;
+
+    // TODO(F2): Scaling/shrinking
+    if( clipAreaImpl( &aDestRange,
+                      aSrcRange,
+                      aDestPoint,
+                      aSrcBounds,
+                      mpImpl->maBounds ))
+    {
+        if( isCompatibleBitmap( rSrcBitmap ) &&
+            isCompatibleClipMask( rMask ) &&
+            isCompatibleClipMask( rClip ) )
+        {
+            drawMaskedBitmap_i( rSrcBitmap, rMask, aSrcRange, aDestRange, drawMode, rClip );
+        }
+        else
+        {
+            OSL_ENSURE( false, "Generic output not yet implemented!" );
+        }
+    }
+}
+
+
+//----------------------------------------------------------------------------------
+
+typedef PaletteImageAccessor<Color,sal_uInt8>                               PaletteAccessor;
+typedef BitmapRenderer<MaskIterator,PaletteAccessor >                       OneBitMsbPaletteRenderer;
+typedef BitmapRenderer<AlphaMaskIterator,AlphaMaskAccessor>                 EightBitTrueColorRenderer;
+typedef PixelIterator<Color>                                                ThirtyTwoBitPixelIterator;
+typedef BitmapRenderer<ThirtyTwoBitPixelIterator,
+                       vigra::AccessorTraits<Color>::default_accessor>      ThirtyTwoBitTrueColorRenderer;
+
+BitmapDeviceSharedPtr createBitmapDevice( const basegfx::B2IVector& rSize,
+                                          bool                      bTopDown,
+                                          sal_Int32                 nScanlineFormat )
+{
+    sal_Int32  nScanlineStride(0);
+
+    // HACK: 1bpp and 24bpp only, currently
+    if( nScanlineFormat == Format::ONE_BIT_MSB_PAL )
+        nScanlineStride = (rSize.getX() + 7) >> 3;
+    else if( nScanlineFormat == Format::EIGHT_BIT_TC_MASK )
+        nScanlineStride = rSize.getX();
+    else if( nScanlineFormat == Format::THIRTYTWO_BIT_TC_MASK )
+        nScanlineStride = 4*rSize.getX();
+
+    nScanlineStride *= bTopDown ? 1 : -1;
+
+    const std::size_t nMemSize(
+        (nScanlineStride < 0 ? -nScanlineStride : nScanlineStride)*rSize.getY() );
+
+    boost::shared_ptr< sal_uInt8 > pMem(
+        reinterpret_cast<sal_uInt8*>(rtl_allocateMemory( nMemSize )),
+        &rtl_freeMemory );
+    sal_uInt8* pFirstScanline = nScanlineStride < 0 ?
+        pMem.get() + nMemSize : pMem.get();
+
+    rtl_zeroMemory(pMem.get(),nMemSize);
+
+    switch( nScanlineFormat )
+    {
+        case Format::ONE_BIT_MSB_PAL:
+        {
+            static Color bwPalette[] = { Color(0x00000000),
+                                         Color(0xFFFFFFFF) };
+
+            return BitmapDeviceSharedPtr(
+                new OneBitMsbPaletteRenderer(
+                    rSize,
+                    bTopDown,
+                    nScanlineFormat,
+                    nScanlineStride,
+                    MaskIterator(pFirstScanline,
+                                 nScanlineStride),
+                    MaskIterator(pFirstScanline,
+                                 nScanlineStride)
+                    + vigra::Diff2D(rSize.getX(),
+                                    rSize.getY()),
+                    PaletteAccessor( bwPalette,
+                                     sizeof(bwPalette)/sizeof(*bwPalette)),
+                    pMem ));
+        }
+
+        case Format::EIGHT_BIT_TC_MASK:
+        {
+            return BitmapDeviceSharedPtr(
+                new EightBitTrueColorRenderer(
+                    rSize,
+                    bTopDown,
+                    nScanlineFormat,
+                    nScanlineStride,
+                    AlphaMaskIterator(pFirstScanline,
+                                      nScanlineStride),
+                    AlphaMaskIterator(pFirstScanline,
+                                      nScanlineStride)
+                    + vigra::Diff2D(rSize.getX(),
+                                    rSize.getY()),
+                    AlphaMaskAccessor(),
+                    pMem ));
+        }
+
+        case Format::THIRTYTWO_BIT_TC_MASK:
+        {
+            return BitmapDeviceSharedPtr(
+                new ThirtyTwoBitTrueColorRenderer(
+                    rSize,
+                    bTopDown,
+                    nScanlineFormat,
+                    nScanlineStride,
+                    ThirtyTwoBitPixelIterator(reinterpret_cast<Color*>(pFirstScanline),
+                                              nScanlineStride),
+                    ThirtyTwoBitPixelIterator(reinterpret_cast<Color*>(pFirstScanline),
+                                              nScanlineStride)
+                    + vigra::Diff2D(rSize.getX(),
+                                    rSize.getY()),
+                    vigra::AccessorTraits<Color>::default_accessor(),
+                    pMem ));
+        }
+
+        default:
+            // TODO(F3): other formats not yet implemented
+            return BitmapDeviceSharedPtr();
+    }
+}
+
+} // namespace basebmp
diff --git a/basebmp/source/debug.cxx b/basebmp/source/debug.cxx
new file mode 100644
index 000000000000..cb168a82db9f
--- /dev/null
+++ b/basebmp/source/debug.cxx
@@ -0,0 +1,117 @@
+/*************************************************************************
+ *
+ *  $RCSfile: debug.cxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: thb $ $Date: 2006-05-31 09:49:44 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *  MA  02111-1307  USA
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (the "License"); You may not use this file
+ *  except in compliance with the License. You may obtain a copy of the
+ *  License at http://www.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+
+#include <osl/diagnose.h>
+
+#include <basegfx/point/b2ipoint.hxx>
+#include <basegfx/vector/b2ivector.hxx>
+
+#include <basebmp/scanlineformats.hxx>
+#include <basebmp/color.hxx>
+#include <basebmp/bitmapdevice.hxx>
+#include <basebmp/debug.hxx>
+
+#include <iomanip>
+
+namespace basebmp
+{
+    namespace
+    {
+        static const char* getFormatString( sal_Int32 nScanlineFormat )
+        {
+            switch( nScanlineFormat )
+            {
+                case Format::ONE_BIT_MSB_PAL:
+                    return "ONE_BIT_MSB_PAL";
+                case Format::EIGHT_BIT_TC_MASK:
+                    return "EIGHT_BIT_TC_MASK";
+                case Format::THIRTYTWO_BIT_TC_MASK:
+                    return "THIRTYTWO_BIT_TC_MASK";
+                default:
+                    return "<unknown>";
+            }
+        }
+    }
+
+    void debugDump( const BitmapDeviceSharedPtr& rDevice,
+                    std::ostream&                rOutputStream )
+    {
+        const basegfx::B2IVector aSize( rDevice->getSize() );
+        const bool               bTopDown( rDevice->isTopDown() );
+        const sal_Int32          nScanlineFormat( rDevice->getScanlineFormat() );
+
+        rOutputStream
+            << "/* basebmp::BitmapDevice memory dump */" << std::endl
+            << "/* Width   = " << aSize.getX() << " */" << std::endl
+            << "/* Height  = " << aSize.getY() << " */" << std::endl
+            << "/* TopDown = " << bTopDown << " */" << std::endl
+            << "/* Format  = " << getFormatString(nScanlineFormat) << " */" << std::endl
+            << std::endl;
+
+        rOutputStream << std::hex;
+        for( int y=0; y<aSize.getY(); ++y )
+        {
+            for( int x=0; x<aSize.getX(); ++x )
+                rOutputStream << std::setw(8) << (sal_uInt32)rDevice->getPixel( basegfx::B2IPoint(x,y) ) << " ";
+            rOutputStream << std::endl;
+        }
+    }
+}
diff --git a/basebmp/source/makefile.mk b/basebmp/source/makefile.mk
new file mode 100644
index 000000000000..827b53606b07
--- /dev/null
+++ b/basebmp/source/makefile.mk
@@ -0,0 +1,54 @@
+#*************************************************************************
+#
+#   OpenOffice.org - a multi-platform office productivity suite
+#
+#   $RCSfile: makefile.mk,v $
+#
+#   $Revision: 1.1 $
+#
+#   last change: $Author: thb $ $Date: 2006-05-31 09:49:44 $
+#
+#   The Contents of this file are made available subject to
+#   the terms of GNU Lesser General Public License Version 2.1.
+#
+#
+#     GNU Lesser General Public License Version 2.1
+#     =============================================
+#     Copyright 2005 by Sun Microsystems, Inc.
+#     901 San Antonio Road, Palo Alto, CA 94303, USA
+#
+#     This library is free software; you can redistribute it and/or
+#     modify it under the terms of the GNU Lesser General Public
+#     License version 2.1, as published by the Free Software Foundation.
+#
+#     This library is distributed in the hope that it will be useful,
+#     but WITHOUT ANY WARRANTY; without even the implied warranty of
+#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#     Lesser General Public License for more details.
+#
+#     You should have received a copy of the GNU Lesser General Public
+#     License along with this library; if not, write to the Free Software
+#     Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+#     MA  02111-1307  USA
+#
+#*************************************************************************
+
+PRJ=..$/
+
+PRJNAME=basebmp
+TARGET=wrapper
+ENABLE_EXCEPTIONS=TRUE
+
+# --- Settings -----------------------------------------------------------
+
+.INCLUDE :	settings.mk
+
+# --- Common ----------------------------------------------------------
+
+SLOFILES =	\
+    $(SLO)$/bitmapdevice.obj \
+    $(SLO)$/debug.obj
+
+# ==========================================================================
+
+.INCLUDE :	target.mk
diff --git a/basebmp/test/basictest.cxx b/basebmp/test/basictest.cxx
new file mode 100644
index 000000000000..ef819c81ab6e
--- /dev/null
+++ b/basebmp/test/basictest.cxx
@@ -0,0 +1,133 @@
+// autogenerated file with codegen.pl
+
+#include <cppunit/simpleheader.hxx>
+
+#include <basegfx/vector/b2isize.hxx>
+#include <basegfx/point/b2ipoint.hxx>
+
+#include <basebmp/color.hxx>
+#include <basebmp/scanlineformats.hxx>
+#include <basebmp/bitmapdevice.hxx>
+
+using namespace ::basebmp;
+
+namespace
+{
+
+class BasicTest : public CppUnit::TestFixture
+{
+public:
+    void testConstruction()
+    {
+        const basegfx::B2ISize aSize(101,101);
+        basegfx::B2ISize       aSize2(aSize);
+        BitmapDeviceSharedPtr pDevice( createBitmapDevice( aSize,
+                                                           true,
+                                                           Format::ONE_BIT_MSB_PAL ));
+        CPPUNIT_ASSERT_MESSAGE("right size",
+                               pDevice->getSize() == aSize2 );
+        CPPUNIT_ASSERT_MESSAGE("Top down format",
+                               pDevice->isTopDown() == true );
+        CPPUNIT_ASSERT_MESSAGE("Scanline format",
+                               pDevice->getScanlineFormat() == Format::ONE_BIT_MSB_PAL );
+        CPPUNIT_ASSERT_MESSAGE("Scanline len",
+                               pDevice->getScanlineStride() == (aSize2.getY() + 7)/8 );
+    }
+
+    void testPixelFuncs()
+    {
+        // 1bpp
+        const basegfx::B2ISize aSize(101,101);
+        BitmapDeviceSharedPtr pDevice( createBitmapDevice( aSize,
+                                                           true,
+                                                           Format::ONE_BIT_MSB_PAL ));
+
+        const basegfx::B2IPoint aPt(3,3);
+        const Color aCol(0xFFFFFFFF);
+        pDevice->setPixel( aPt, aCol, DrawMode_PAINT );
+        CPPUNIT_ASSERT_MESSAGE("get/setPixel roundtrip #1",
+                               pDevice->getPixel(aPt) == aCol);
+
+        const basegfx::B2IPoint aPt2(0,0);
+        const Color aCol2(0xFFFFFFFF);
+        pDevice->setPixel( aPt2, aCol2, DrawMode_PAINT );
+        CPPUNIT_ASSERT_MESSAGE("get/setPixel roundtrip #2",
+                               pDevice->getPixel(aPt2) == aCol2);
+
+        const basegfx::B2IPoint aPt3(aSize.getX()-1,aSize.getY()-1);
+        const Color aCol3(0x00000000);
+        pDevice->setPixel( aPt3, aCol3, DrawMode_PAINT );
+        CPPUNIT_ASSERT_MESSAGE("get/setPixel roundtrip #3",
+                               pDevice->getPixel(aPt3) == aCol3);
+
+        const basegfx::B2IPoint aPt4(-100000,-100000);
+        pDevice->setPixel( aPt4, aCol3, DrawMode_PAINT );
+        const basegfx::B2IPoint aPt5(100000,100000);
+        pDevice->setPixel( aPt5, aCol3, DrawMode_PAINT );
+
+        // 8bpp
+        {
+            pDevice = createBitmapDevice( aSize,
+                                          true,
+                                          Format::EIGHT_BIT_TC_MASK );
+
+            const Color aCol4(0x01);
+            pDevice->setPixel( aPt, aCol4, DrawMode_PAINT );
+            CPPUNIT_ASSERT_MESSAGE("get/setPixel roundtrip #4",
+                                   pDevice->getPixel(aPt) == aCol4);
+
+            const Color aCol5(0x0F);
+            pDevice->setPixel( aPt2, aCol5, DrawMode_PAINT );
+            CPPUNIT_ASSERT_MESSAGE("get/setPixel roundtrip #5",
+                                   pDevice->getPixel(aPt2) == aCol5);
+
+            const Color aCol6(0xFF);
+            pDevice->setPixel( aPt3, aCol6, DrawMode_PAINT );
+            CPPUNIT_ASSERT_MESSAGE("get/setPixel roundtrip #6",
+                                   pDevice->getPixel(aPt3) == aCol6);
+        }
+
+        // 32bpp
+        {
+            pDevice = createBitmapDevice( aSize,
+                                          true,
+                                          Format::THIRTYTWO_BIT_TC_MASK );
+
+            const Color aCol4(0x01010101);
+            pDevice->setPixel( aPt, aCol4, DrawMode_PAINT );
+            CPPUNIT_ASSERT_MESSAGE("get/setPixel roundtrip #7",
+                                   pDevice->getPixel(aPt) == aCol4);
+
+            const Color aCol5(0x0F0F0F0F);
+            pDevice->setPixel( aPt2, aCol5, DrawMode_PAINT );
+            CPPUNIT_ASSERT_MESSAGE("get/setPixel roundtrip #8",
+                                   pDevice->getPixel(aPt2) == aCol5);
+
+            const Color aCol6(0xFFFFFFFF);
+            pDevice->setPixel( aPt3, aCol6, DrawMode_PAINT );
+            CPPUNIT_ASSERT_MESSAGE("get/setPixel roundtrip #9",
+                                   pDevice->getPixel(aPt3) == aCol6);
+        }
+    }
+
+    // Change the following lines only, if you add, remove or rename
+    // member functions of the current class,
+    // because these macros are need by auto register mechanism.
+
+    CPPUNIT_TEST_SUITE(BasicTest);
+    CPPUNIT_TEST(testConstruction);
+    CPPUNIT_TEST(testPixelFuncs);
+    CPPUNIT_TEST_SUITE_END();
+};
+
+// -----------------------------------------------------------------------------
+CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(BasicTest, "BasicTest");
+}
+
+
+// -----------------------------------------------------------------------------
+
+// this macro creates an empty function, which will called by the RegisterAllFunctions()
+// to let the user the possibility to also register some functions by hand.
+NOADDITIONAL;
+
diff --git a/basebmp/test/bmpdemo.cxx b/basebmp/test/bmpdemo.cxx
new file mode 100644
index 000000000000..29d5c143b4af
--- /dev/null
+++ b/basebmp/test/bmpdemo.cxx
@@ -0,0 +1,1278 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: bmpdemo.cxx,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: thb $ $Date: 2006-05-31 09:49:44 $
+ *
+ *  The Contents of this file are made available subject to
+ *  the terms of GNU Lesser General Public License Version 2.1.
+ *
+ *
+ *    GNU Lesser General Public License Version 2.1
+ *    =============================================
+ *    Copyright 2005 by Sun Microsystems, Inc.
+ *    901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *    This library is free software; you can redistribute it and/or
+ *    modify it under the terms of the GNU Lesser General Public
+ *    License version 2.1, as published by the Free Software Foundation.
+ *
+ *    This library is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *    Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with this library; if not, write to the Free Software
+ *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *    MA  02111-1307  USA
+ *
+ ************************************************************************/
+
+#ifndef  _USE_MATH_DEFINES
+#define  _USE_MATH_DEFINES  // needed by Visual C++ for math constants
+#endif
+#include <math.h>
+
+#include <comphelper/processfactory.hxx>
+#include <comphelper/regpathhelper.hxx>
+#include <cppuhelper/servicefactory.hxx>
+#include <cppuhelper/bootstrap.hxx>
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+#include <com/sun/star/lang/XInitialization.hpp>
+#include <com/sun/star/registry/XSimpleRegistry.hpp>
+
+#include <ucbhelper/contentbroker.hxx>
+#include <ucbhelper/configurationkeys.hxx>
+
+#include <vcl/window.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/msgbox.hxx>
+#include <vcl/unowrap.hxx>
+#include <vcl/bitmap.hxx>
+#include <vcl/bmpacc.hxx>
+
+#include <basegfx/polygon/b2dpolypolygonrasterconverter.hxx>
+#include <basegfx/polygon/b2dpolygontools.hxx>
+#include <basegfx/polygon/b2dpolygon.hxx>
+#include <basegfx/numeric/ftools.hxx>
+#include <basegfx/vector/b2isize.hxx>
+#include <basegfx/point/b2ipoint.hxx>
+
+#include <basebmp/color.hxx>
+#include <basebmp/scanlineformats.hxx>
+#include <basebmp/bitmapdevice.hxx>
+
+#include <rtl/bootstrap.hxx>
+
+#include <vigra/metaprogramming.hxx>
+#include <vigra/static_assert.hxx>
+#include <vigra/resizeimage.hxx>
+#include <vigra/basicimageview.hxx>
+
+#include <boost/static_assert.hpp>
+#include <algorithm>
+
+using namespace ::com::sun::star;
+
+
+namespace
+{
+
+/// template meta function: add const qualifier, if given 2nd type has it
+template<typename A, typename B> struct clone_const
+{
+    typedef B type;
+};
+template<typename A, typename B> struct clone_const<const A,B>
+{
+    typedef const B type;
+};
+
+template< class DestIterator, class DestAccessor > class Renderer :
+        public basegfx::B2DPolyPolygonRasterConverter
+{
+private:
+    typename DestIterator::value_type fillColor_;
+    typename DestIterator::value_type clearColor_;
+    DestIterator                      begin_;
+    DestAccessor                      accessor_;
+
+public:
+    Renderer(const basegfx::B2DPolyPolygon&     rPolyPolyRaster,
+             typename DestIterator::value_type  fillColor,
+             typename DestIterator::value_type  clearColor,
+             DestIterator                       begin,
+             DestIterator                       end,
+             DestAccessor                       accessor ) :
+        B2DPolyPolygonRasterConverter(rPolyPolyRaster,
+                                      basegfx::B2DRange(0,0,
+                                                        end.x - end.x,
+                                                        begin.y - begin.y )),
+        fillColor_( fillColor ),
+        clearColor_( clearColor ),
+        begin_( begin ),
+        accessor_( accessor )
+    {
+    }
+
+    virtual void span(const double& rfXLeft,
+                      const double& rfXRight,
+                      sal_Int32     nY,
+                      bool          bOn )
+    {
+        DestIterator currIter( begin_ + vigra::Diff2D(0,nY) );
+        typename DestIterator::row_iterator rowIter( currIter.rowIterator() +
+                                                     basegfx::fround(rfXLeft) );
+        typename DestIterator::row_iterator rowEnd( currIter.rowIterator() +
+                                                    basegfx::fround(rfXRight) );
+        if( bOn )
+            while( rowIter != rowEnd )
+            {
+                accessor_.set(fillColor_, rowIter);
+                ++rowIter;
+            }
+        else
+            while( rowIter != rowEnd )
+            {
+                accessor_.set(accessor_(rowIter)*clearColor_, rowIter);
+                ++rowIter;
+            }
+    }
+};
+
+template< class DestIterator, class DestAccessor >
+    std::auto_ptr< Renderer< DestIterator, DestAccessor > > makeRenderer(
+        const basegfx::B2DPolyPolygon&                          rPolyPolyRaster,
+        typename DestIterator::value_type                       fillColor,
+        typename DestIterator::value_type                       clearColor,
+        vigra::triple<DestIterator, DestIterator, DestAccessor> dest )
+{
+    return std::auto_ptr< Renderer< DestIterator, DestAccessor > >(
+        new Renderer< DestIterator, DestAccessor >(rPolyPolyRaster,
+                                                   fillColor,
+                                                   clearColor,
+                                                   dest.first,
+                                                   dest.second,
+                                                   dest.third));
+}
+
+
+// changed semantics re. DirectionSelector<StridedArrayTag>: stride
+// now counts in <em>raw</em> bytes!
+template< typename T > class StridedArrayIterator
+{
+public:
+    typedef typename clone_const<T, unsigned char>::type  internal_type;
+
+    StridedArrayIterator(int stride, T* ptr = 0) :
+        stride_(stride),
+        current_(reinterpret_cast<internal_type*>(ptr))
+    {}
+
+    /// Copy from other StridedArrayIterator, plus given offset
+    StridedArrayIterator( StridedArrayIterator const& rSrc,
+                          int                         offset ) :
+        stride_(rSrc.stride_),
+        current_(reinterpret_cast<internal_type*>(
+                     reinterpret_cast<T*>(rSrc.current_)+offset))
+    {}
+
+    void operator++() {current_ += stride_; }
+    void operator++(int) {current_ += stride_; }
+    void operator--() {current_ -= stride_; }
+    void operator--(int) {current_ -= stride_; }
+    void operator+=(int dy) {current_ += dy*stride_; }
+    void operator-=(int dy) {current_ -= dy*stride_; }
+
+    bool operator==(StridedArrayIterator const & rhs) const
+    { return (current_ == rhs.current_); }
+
+    bool operator!=(StridedArrayIterator const & rhs) const
+    { return (current_ != rhs.current_); }
+
+    bool operator<(StridedArrayIterator const & rhs) const
+    { return (current_ < rhs.current_); }
+
+    bool operator<=(StridedArrayIterator const & rhs) const
+    { return (current_ <= rhs.current_); }
+
+    bool operator>(StridedArrayIterator const & rhs) const
+    { return (current_ > rhs.current_); }
+
+    bool operator>=(StridedArrayIterator const & rhs) const
+    { return (current_ >= rhs.current_); }
+
+    int operator-(StridedArrayIterator const & rhs) const
+    { return (current_ - rhs.current_) / stride_; }
+
+    T* operator()() const
+    { return reinterpret_cast<T*>(current_); }
+
+    T* operator()(int d) const
+    { return reinterpret_cast<T*>(current_ + d*stride_); }
+
+    int            stride_;
+    internal_type* current_;
+};
+
+/// template meta function: remove const qualifier from plain type
+template <typename T> struct remove_const
+{
+    typedef T type;
+};
+template <typename T> struct remove_const<const T>
+{
+    typedef T type;
+};
+
+/// returns true, if given number is strictly less than 0
+template< typename T > inline bool is_negative( T x )
+{
+    return x < 0;
+}
+
+/// Overload for ints (branch-free)
+inline bool is_negative( int x )
+{
+    // force logic shift (result for signed shift right is undefined)
+    return static_cast<unsigned int>(x) >> (sizeof(int)*8-1);
+}
+
+/// Get bitmask for data at given intra-word position, for given bit depth
+template< typename data_type, int bits_per_pixel, bool MsbFirst, typename difference_type > inline data_type get_mask( difference_type d )
+{
+    BOOST_STATIC_ASSERT(bits_per_pixel > 0);
+    BOOST_STATIC_ASSERT(sizeof(data_type)*8 % bits_per_pixel == 0);
+    BOOST_STATIC_ASSERT(sizeof(data_type)*8 / bits_per_pixel > 1);
+    BOOST_STATIC_ASSERT(vigra::TypeTraits<data_type>::isPOD::asBool);
+
+    const unsigned int nIntraWordPositions( sizeof(data_type)*8 / bits_per_pixel );
+
+    //      create bits_per_pixel 1s      shift to intra-word position
+    return ((~(~0 << bits_per_pixel)) << bits_per_pixel*(MsbFirst ?
+                                                         (nIntraWordPositions-1 - (d % nIntraWordPositions)) :
+                                                         (d % nIntraWordPositions)));
+}
+
+template< int num_intraword_positions, int bits_per_pixel, bool MsbFirst, typename difference_type > inline difference_type get_shift( difference_type remainder )
+{
+    return bits_per_pixel*(MsbFirst ?
+                           (num_intraword_positions - 1 - remainder) :
+                           remainder);
+}
+
+template< typename Datatype,
+          typename Valuetype,
+          int      bits_per_pixel,
+          bool     MsbFirst > class PackedPixelColumnIterator
+{
+public:
+    // no reference, no index_reference type here
+    typedef Datatype                                    data_type;
+    typedef Valuetype                                   value_type;
+    typedef int                                         difference_type;
+    typedef image_traverser_tag                         iterator_category;
+
+    typedef typename remove_const<data_type>::type      mask_type;
+    typedef data_type*                                  pointer;
+    typedef StridedArrayIterator< data_type >           MoveY;
+
+    enum {
+        /** The number of pixel within a single data_type value
+         */
+        num_intraword_positions=sizeof(data_type)*8/bits_per_pixel,
+        /** Bit mask for one pixel (least significant bits)
+         */
+        bit_mask=~(~0 << bits_per_pixel)
+    };
+
+private:
+    MoveY           y;
+    mask_type       mask_;
+    difference_type shift_;
+
+    void inc()
+    {
+        ++y;
+    }
+
+    void dec()
+    {
+        --y;
+    }
+
+    bool equal( PackedPixelColumnIterator const & rhs ) const
+    {
+        return rhs.y == y;
+    }
+
+    bool less( PackedPixelColumnIterator const & rhs ) const
+    {
+        return y < rhs.y;
+    }
+
+public:
+    PackedPixelColumnIterator() :
+        y(0),
+        mask_( get_mask<data_type, bits_per_pixel, MsbFirst, difference_type>(0) ),
+        shift_( get_shift<num_intraword_positions, bits_per_pixel, MsbFirst, difference_type>(0) )
+    {}
+
+    PackedPixelColumnIterator( const MoveY& base, difference_type remainder ) :
+        y(base),
+        mask_( get_mask<data_type, bits_per_pixel, MsbFirst>(remainder) ),
+        shift_( get_shift<num_intraword_positions, bits_per_pixel, MsbFirst>(remainder) )
+    {}
+
+    PackedPixelColumnIterator& operator+=( difference_type d )
+    {
+        y += d;
+        return *this;
+    }
+
+    PackedPixelColumnIterator& operator-=( difference_type d )
+    {
+        y -= d;
+        return *this;
+    }
+
+    PackedPixelColumnIterator operator+( difference_type d )
+    {
+        PackedPixelColumnIterator res(*this);
+        res += d;
+        return res;
+    }
+
+    PackedPixelColumnIterator operator-( difference_type d )
+    {
+        PackedPixelColumnIterator res(*this);
+        res -= d;
+        return res;
+    }
+
+    PackedPixelColumnIterator& operator++()
+    {
+        inc();
+        return *this;
+    }
+
+    PackedPixelColumnIterator& operator--()
+    {
+        dec();
+        return *this;
+    }
+
+    PackedPixelColumnIterator operator++(int)
+    {
+        PackedPixelColumnIterator res(*this);
+        res.inc();
+        return res;
+    }
+
+    PackedPixelColumnIterator operator--(int)
+    {
+        PackedPixelColumnIterator res(*this);
+        res.dec();
+        return res;
+    }
+
+    bool operator==(PackedPixelColumnIterator const & rhs) const
+    {
+        return equal( rhs );
+    }
+
+    bool operator!=(PackedPixelColumnIterator const & rhs) const
+    {
+        return !equal( rhs );
+    }
+
+    bool operator<(PackedPixelColumnIterator const & rhs) const
+    {
+        return less(rhs);
+    }
+
+    bool operator<=(PackedPixelColumnIterator const & rhs) const
+    {
+        return !less(rhs);
+    }
+
+    bool operator>(PackedPixelColumnIterator const & rhs) const
+    {
+        return rhs.less(*this);
+    }
+
+    bool operator>=(PackedPixelColumnIterator const & rhs) const
+    {
+        return !rhs.less(*this);
+    }
+
+    difference_type operator-(PackedPixelColumnIterator const & rhs) const
+    {
+        return y - rhs.y;
+    }
+
+    value_type get() const
+    {
+        // TODO(Q3): use traits to get unsigned type for data_type (if
+        // not already)
+        return static_cast<unsigned int>(*y() & mask_) >> shift_;
+    }
+
+    value_type get(difference_type d) const
+    {
+        // TODO(Q3): use traits to get unsigned type for data_type (if
+        // not already)
+        return static_cast<unsigned int>(*y(d) & mask_) >> shift_;
+    }
+
+    void set( value_type v ) const
+    {
+        const value_type pixel_value( (v << shift_) & mask_ );
+        *y() = (*y() & ~mask_) | pixel_value;
+    }
+
+    void set( value_type v, difference_type d ) const
+    {
+        const value_type pixel_value( (v << shift_) & mask_ );
+        *y(d) = (*y(d) & ~mask_) | pixel_value;
+    }
+};
+
+template< typename Datatype,
+          typename Valuetype,
+          int      bits_per_pixel,
+          bool     MsbFirst > class PackedPixelRowIterator
+{
+public:
+    // no reference, no index_reference type here
+    typedef Datatype                                    data_type;
+    typedef Valuetype                                   value_type;
+    typedef int                                         difference_type;
+    typedef image_traverser_tag                         iterator_category;
+
+    typedef typename remove_const<data_type>::type      mask_type;
+    typedef data_type*                                  pointer;
+
+    enum {
+        /** The number of pixel within a single data_type value
+         */
+        num_intraword_positions=sizeof(data_type)*8/bits_per_pixel,
+        /** Bit mask for one pixel (least significant bits)
+         */
+        bit_mask=~(~0 << bits_per_pixel)
+    };
+
+private:
+    pointer         data_;
+    mask_type       mask_;
+    difference_type remainder_;
+
+    void update_mask()
+    {
+        mask_ = get_mask<data_type, bits_per_pixel, MsbFirst>(remainder_);
+    }
+
+    void inc()
+    {
+        const difference_type newValue( remainder_ + 1 );
+        const difference_type data_offset( newValue / num_intraword_positions );
+
+        data_ += data_offset;
+        remainder_ = newValue % num_intraword_positions;
+
+        const mask_type shifted_mask(
+            MsbFirst ?
+            // TODO(Q3): use traits to get unsigned type for data_type
+            // (if not already)
+            static_cast<unsigned int>(mask_) >> bits_per_pixel :
+            mask_ << bits_per_pixel );
+
+        // data_offset is 0 for shifted mask, and 1 for wrapped-around mask
+        mask_ = (1-data_offset)*shifted_mask + data_offset*(MsbFirst ?
+                                                            bit_mask << bits_per_pixel*(num_intraword_positions-1) :
+                                                            bit_mask);
+    }
+
+    void dec()
+    {
+        const difference_type newValue( remainder_ - 1 );
+        const bool            isNegative( is_negative(newValue) );
+        const difference_type newRemainder( newValue % num_intraword_positions );
+
+        // calc  data_ += newValue / num_intraword_positions;
+        //       remainder_ = newRemainder;
+        // for newValue >= 0, and
+        //       data_ += newValue / num_intraword_positions - 1;
+        //       remainder_ = num_intraword_positions - newRemainder;
+        // (to force remainder_ to be positive).
+        // This is branch-free, if is_negative() is branch-free
+        const difference_type data_offset( newValue / num_intraword_positions - isNegative );
+        data_     += data_offset;
+        remainder_ = newRemainder + isNegative*num_intraword_positions;
+
+        const mask_type shifted_mask(
+            MsbFirst ?
+            mask_ << bits_per_pixel :
+            // TODO(Q3): use traits to get unsigned type for data_type
+            // (if not already)
+            static_cast<unsigned int>(mask_) >> bits_per_pixel );
+
+        // data_offset is 0 for shifted mask, and 1 for wrapped-around mask
+        mask_ = (1-data_offset)*shifted_mask + data_offset*(MsbFirst ?
+                                                            bit_mask :
+                                                            bit_mask << bits_per_pixel*(num_intraword_positions-1));
+    }
+
+    bool equal( PackedPixelRowIterator const & rhs ) const
+    {
+        return rhs.data_ == data_ && rhs.remainder_ == remainder_;
+    }
+
+    bool less( PackedPixelRowIterator const & rhs ) const
+    {
+        return data_ == rhs.data_ ?
+            (remainder_ < rhs.remainder_) :
+            (data_ < rhs.data_);
+    }
+
+public:
+    PackedPixelRowIterator() :
+        data_(0),
+        mask_( get_mask<data_type, bits_per_pixel, MsbFirst, difference_type>(0) ),
+        remainder_(0)
+    {}
+
+    explicit PackedPixelRowIterator( pointer base ) :
+        data_(base),
+        mask_( get_mask<data_type, bits_per_pixel, MsbFirst, difference_type>(0) ),
+        remainder_(0)
+    {}
+
+    PackedPixelRowIterator& operator+=( difference_type d )
+    {
+        const difference_type newValue( remainder_ + d );
+
+        data_ += newValue / num_intraword_positions;
+        remainder_ = newValue % num_intraword_positions;
+        update_mask();
+
+        return *this;
+    }
+
+    PackedPixelRowIterator& operator-=( difference_type d )
+    {
+        const difference_type newValue( remainder_ - d );
+        const bool            isNegative( is_negative(newValue) );
+        const difference_type newRemainder( newValue % num_intraword_positions );
+
+        // calc  data_ += newValue / num_intraword_positions;
+        //       remainder_ = newRemainder;
+        // for newValue >= 0, and
+        //       data_ += newValue / num_intraword_positions - 1;
+        //       remainder_ = num_intraword_positions - newRemainder;
+        // (to force remainder_ to be positive).
+        // This is branch-free, if is_negative() is branch-free
+        data_     += newValue / num_intraword_positions - isNegative;
+        remainder_ = newRemainder + isNegative*(num_intraword_positions - 2*newRemainder);
+        update_mask();
+
+        return *this;
+    }
+
+    PackedPixelRowIterator operator+( difference_type d )
+    {
+        PackedPixelRowIterator res(*this);
+        res += d;
+        return res;
+    }
+
+    PackedPixelRowIterator operator-( difference_type d )
+    {
+        PackedPixelRowIterator res(*this);
+        res -= d;
+        return res;
+    }
+
+    PackedPixelRowIterator& operator++()
+    {
+        inc();
+        return *this;
+    }
+
+    PackedPixelRowIterator& operator--()
+    {
+        dec();
+        return *this;
+    }
+
+    PackedPixelRowIterator operator++(int)
+    {
+        PackedPixelRowIterator res(*this);
+        res.inc();
+        return res;
+    }
+
+    PackedPixelRowIterator operator--(int)
+    {
+        PackedPixelRowIterator res(*this);
+        res.dec();
+        return res;
+    }
+
+    bool operator==(PackedPixelRowIterator const & rhs) const
+    {
+        return equal( rhs );
+    }
+
+    bool operator!=(PackedPixelRowIterator const & rhs) const
+    {
+        return !equal( rhs );
+    }
+
+    bool operator<(PackedPixelRowIterator const & rhs) const
+    {
+        return less(rhs);
+    }
+
+    bool operator<=(PackedPixelRowIterator const & rhs) const
+    {
+        return !less(rhs);
+    }
+
+    bool operator>(PackedPixelRowIterator const & rhs) const
+    {
+        return rhs.less(*this);
+    }
+
+    bool operator>=(PackedPixelRowIterator const & rhs) const
+    {
+        return !rhs.less(*this);
+    }
+
+    difference_type operator-(PackedPixelRowIterator const & rhs) const
+    {
+        return (data_ - rhs.data_)*num_intraword_positions + (remainder_ - rhs.remainder_);
+    }
+
+    value_type get() const
+    {
+        // TODO(Q3): use traits to get unsigned type for data_type (if
+        // not already)
+        return static_cast<unsigned int>(*data_ & mask_) >>
+            get_shift<num_intraword_positions, bits_per_pixel, MsbFirst>(remainder_);
+    }
+
+    value_type get(difference_type d) const
+    {
+        PackedPixelRowIterator tmp(*this);
+        tmp += d;
+        return tmp.get();
+    }
+
+    void set( value_type v ) const
+    {
+        const value_type pixel_value(
+            (v <<
+             get_shift<num_intraword_positions, bits_per_pixel, MsbFirst>(remainder_))
+            & mask_ );
+        *data_ = (*data_ & ~mask_) | pixel_value;
+    }
+
+    void set( value_type v, difference_type d ) const
+    {
+        PackedPixelRowIterator tmp(*this);
+        tmp += d;
+        tmp.set(v);
+    }
+};
+
+template< typename Datatype,
+          typename Valuetype,
+          int      bits_per_pixel,
+          bool     MsbFirst > class PackedPixelIterator
+{
+public:
+    // no reference, no index_reference type here
+    typedef Datatype                                    data_type;
+    typedef Valuetype                                   value_type;
+    typedef vigra::Diff2D                               difference_type;
+    typedef image_traverser_tag                         iterator_category;
+    typedef PackedPixelRowIterator<data_type,
+                                   value_type,
+                                   bits_per_pixel,
+                                   MsbFirst>            row_iterator;
+    typedef PackedPixelColumnIterator<data_type,
+                                      value_type,
+                                      bits_per_pixel,
+                                      MsbFirst>         column_iterator;
+
+    typedef data_type*                                  pointer;
+    typedef int                                         MoveX;
+    typedef StridedArrayIterator< data_type >           MoveY;
+
+    enum {
+        /** The number of pixel within a single data_type value
+         */
+        num_intraword_positions=sizeof(data_type)*8/bits_per_pixel,
+        /** Bit mask for one pixel (least significant bits)
+         */
+        bit_mask=~(~0 << bits_per_pixel)
+    };
+
+    // TODO(F2): direction of iteration (ImageIterator can be made to
+    // run backwards)
+
+private:
+    pointer current() const
+    {
+        return y() + (x / num_intraword_positions);
+    }
+
+    pointer current(int dx, int dy) const
+    {
+        return y(dy) + ((x+dx)/num_intraword_positions);
+    }
+
+    bool equal(PackedPixelIterator const & rhs) const
+    {
+        return (x == rhs.x) && (y == rhs.y);
+    }
+
+public:
+    PackedPixelIterator() :
+        x(0),
+        y(0)
+    {}
+
+    PackedPixelIterator(pointer base, int ystride) :
+        x(0),
+        y(ystride,base)
+    {}
+
+    bool operator==(PackedPixelIterator const & rhs) const
+    {
+        return equal(rhs);
+    }
+
+    bool operator!=(PackedPixelIterator const & rhs) const
+    {
+        return !equal(rhs);
+    }
+
+    difference_type operator-(PackedPixelIterator const & rhs) const
+    {
+        return difference_type(x - rhs.x, y - rhs.y);
+    }
+
+    MoveX x;
+    MoveY y;
+
+    PackedPixelIterator & operator+=(difference_type const & s)
+    {
+        x += s.x;
+        y += s.y;
+        return *this;
+    }
+
+    PackedPixelIterator & operator-=(difference_type const & s)
+    {
+        x -= s.x;
+        y -= s.y;
+        return *this;
+    }
+
+    PackedPixelIterator operator+(difference_type const & s) const
+    {
+        PackedPixelIterator ret(*this);
+        ret += s;
+        return ret;
+    }
+
+    PackedPixelIterator operator-(difference_type const & s) const
+    {
+        PackedPixelIterator ret(*this);
+        ret -= s;
+        return ret;
+    }
+
+    row_iterator rowIterator() const
+    {
+        return row_iterator(current());
+    }
+
+    column_iterator columnIterator() const
+    {
+        return column_iterator(MoveY(y,
+                                     x / num_intraword_positions),
+                               x % num_intraword_positions);
+    }
+
+    value_type get() const
+    {
+        const int remainder( x() % num_intraword_positions );
+
+        // TODO(Q3): use traits to get unsigned type for data_type (if
+        // not already)
+        return (static_cast<unsigned int>(*current() &
+                                          get_mask<data_type, bits_per_pixel, MsbFirst>(remainder))
+                >> (MsbFirst ?
+                    (num_intraword_positions - remainder) :
+                    remainder));
+    }
+
+    value_type get(difference_type const & d) const
+    {
+        const int remainder( x(d.x) % num_intraword_positions );
+
+        // TODO(Q3): use traits to get unsigned type for data_type (if
+        // not already)
+        return (static_cast<unsigned int>(*current(d.x,d.y) &
+                                          get_mask<data_type, bits_per_pixel, MsbFirst>(remainder))
+                >> get_shift<num_intraword_positions, bits_per_pixel, MsbFirst>(remainder));
+    }
+
+    void set( value_type v ) const
+    {
+        const int remainder( x() % num_intraword_positions );
+        const int mask( get_mask<data_type, bits_per_pixel, MsbFirst>(remainder) );
+        const value_type pixel_value(
+            (v <<
+             get_shift<num_intraword_positions, bits_per_pixel, MsbFirst>(remainder))
+            & mask );
+        pointer p = current();
+        *p = (*p & ~mask) | pixel_value;
+    }
+
+    void set( value_type v, difference_type const & d ) const
+    {
+        const int remainder( x(d.x) % num_intraword_positions );
+        const int mask( get_mask<data_type, bits_per_pixel, MsbFirst>(remainder) );
+        const value_type pixel_value(
+            (v <<
+             get_shift<num_intraword_positions, bits_per_pixel, MsbFirst>(remainder))
+             & mask );
+        pointer p = current(d.x,d.y);
+        *p = (*p & ~mask) | pixel_value;
+    }
+};
+
+
+/** Access (possibly packed-pixel) data via palette indirection
+ */
+template< typename Valuetype, typename Datatype > class PaletteImageAccessor
+{
+  public:
+    typedef Valuetype                                   value_type;
+    typedef Datatype                                    data_type;
+    typedef typename remove_const<data_type>::type      count_type;
+
+
+private:
+    const BitmapColor* palette;
+    count_type         num_entries;
+
+    double norm( BitmapColor const& rLHS,
+                 BitmapColor const& rRHS ) const
+    {
+        // convert RGBValue's linear space to a normed linear space
+        return sqrt(
+            vigra::sq(rLHS.GetRed()-rRHS.GetRed()) +
+            vigra::sq(rLHS.GetGreen()-rRHS.GetGreen()) +
+            vigra::sq(rLHS.GetBlue()-rRHS.GetBlue()) );
+    }
+
+    data_type find_best_match(value_type const& v) const
+    {
+        // TODO(F3): not generic!!!
+        const BitmapColor aTmpCol(v.red(),
+                                  v.green(),
+                                  v.blue());
+
+        // TODO(P3): use table-based/octree approach here!
+        const BitmapColor* best_entry;
+        const BitmapColor* palette_end( palette+num_entries );
+        if( (best_entry=std::find( palette, palette_end, aTmpCol)) != palette_end )
+            return best_entry-palette;
+
+        // TODO(F3): HACK. Need palette traits, and an error function
+        // here. We blatantly assume value_type is a normed linear
+        // space.
+        const BitmapColor* curr_entry( palette );
+        best_entry = curr_entry;
+        while( curr_entry != palette_end )
+        {
+            if( norm(*curr_entry,*best_entry) > norm(*curr_entry,aTmpCol) )
+                best_entry = curr_entry;
+
+            ++curr_entry;
+        }
+
+        return best_entry-palette;
+    }
+
+    value_type toCol( BitmapColor const& rCol ) const
+    {
+        return value_type(rCol.GetRed(),rCol.GetGreen(),rCol.GetBlue());
+    }
+
+public:
+    PaletteImageAccessor() :
+        palette(0),
+        num_entries(0)
+    {}
+
+    PaletteImageAccessor( const BitmapColor* pPalette,
+                          data_type          entries ) :
+        palette(pPalette),
+        num_entries(entries)
+    {}
+
+    template< class Iterator >
+    value_type operator()(Iterator const& i) const { return toCol(palette[i.get()]); }
+    value_type operator()(data_type const* i) const { return toCol(palette[*i]); }
+
+    template< class Iterator, class Difference >
+    value_type operator()(Iterator const& i, Difference const& diff) const
+    {
+        return toCol(palette[i.get(diff)]);
+    }
+
+    template< typename V, class Iterator >
+    void set(V const& value, Iterator const& i) const
+    {
+        i.set(
+            find_best_match(
+                vigra::detail::RequiresExplicitCast<value_type>::cast(value) ));
+    }
+
+    template< typename V, class Iterator, class Difference >
+    void set(V const& value, Iterator const& i, Difference const& diff) const
+    {
+        i.set(
+            find_best_match(
+                vigra::detail::RequiresExplicitCast<value_type>::cast(value)),
+            diff );
+    }
+};
+
+}
+
+
+class TestApp : public Application
+{
+public:
+    virtual void Main();
+    virtual USHORT  Exception( USHORT nError );
+};
+
+class TestWindow : public Dialog
+{
+    public:
+        TestWindow() : Dialog( (Window *) NULL )
+        {
+            SetText( rtl::OUString::createFromAscii( "VIGRA test" ) );
+            SetSizePixel( Size( 1024, 500 ) );
+            EnablePaint( true );
+            Show();
+        }
+        virtual ~TestWindow() {}
+        virtual void MouseButtonUp( const MouseEvent& rMEvt )
+        {
+            //TODO: do something cool
+            EndDialog();
+        }
+        virtual void Paint( const Rectangle& rRect );
+};
+
+void TestWindow::Paint( const Rectangle& rRect )
+{
+    {
+        const basegfx::B2ISize aSize(11,11);
+        basebmp::BitmapDeviceSharedPtr pDevice( basebmp::createBitmapDevice( aSize,
+                                                                             true,
+                                                                             basebmp::Format::THIRTYTWO_BIT_TC_MASK ));
+
+        const basegfx::B2IPoint aPt1(1,1);
+        const basegfx::B2IPoint aPt2(1,9);
+        const basebmp::Color aCol(0);
+        pDevice->clear( aCol );
+        const basebmp::Color aCol2(0xFFFFFFFF);
+        pDevice->drawLine( aPt1, aPt2, aCol2, basebmp::DrawMode_PAINT );
+    }
+
+    enum{ srcBitDepth=1, dstBitDepth=4 };
+    typedef vigra::RGBValue< sal_uInt8 > RGBVal;
+
+    Bitmap aSourceBitmap( Size(100,100),
+                          srcBitDepth );
+    DrawBitmap( Point(0,350), aSourceBitmap );
+
+    // Fill bitmap with rhombus
+    {
+        ScopedBitmapWriteAccess pWriteAccess( aSourceBitmap.AcquireWriteAccess(),
+                                              aSourceBitmap );
+        pWriteAccess->SetFillColor(0xFF0000);
+        Polygon aPoly(5);
+        aPoly[0] = Point(50,0);
+        aPoly[1] = Point(100,50);
+        aPoly[2] = Point(50,100);
+        aPoly[3] = Point(0,50);
+        aPoly[4] = Point(50,0);
+        pWriteAccess->FillPolygon(aPoly);
+    }
+
+    Bitmap aDestBitmap( Size(300,300),
+                        dstBitDepth );
+
+    {
+        ScopedBitmapReadAccess  pReadAccess( aSourceBitmap.AcquireReadAccess(),
+                                             aSourceBitmap );
+        ScopedBitmapWriteAccess pWriteAccess( aDestBitmap.AcquireWriteAccess(),
+                                              aDestBitmap );
+
+        const sal_Int32     nSrcWidth( pReadAccess->Width() );
+        const sal_Int32     nSrcHeight( pReadAccess->Height() );
+        const bool          bSrcTopDown( pReadAccess->IsTopDown() );
+        const sal_uInt32    nSrcScanlineFormat( pReadAccess->GetScanlineFormat() );
+        const sal_uInt32    nSrcScanlineStride( pReadAccess->GetScanlineSize() );
+        const sal_uInt16    nSrcBitCount( pReadAccess->GetBitCount() );
+        const sal_uInt16    nSrcPaletteEntries( pReadAccess->GetPaletteEntryCount() );
+        const BitmapColor*  pSrcPalette( &pReadAccess->GetPalette()[0] );
+        const BYTE*         pSrcBuffer = pReadAccess->GetBuffer();
+
+        const sal_Int32     nDstWidth( pWriteAccess->Width() );
+        const sal_Int32     nDstHeight( pWriteAccess->Height() );
+        const bool          bDstTopDown( pWriteAccess->IsTopDown() );
+        const sal_uInt32    nDstScanlineFormat( pWriteAccess->GetScanlineFormat() );
+        const sal_uInt32    nDstScanlineStride( pWriteAccess->GetScanlineSize() );
+        const sal_uInt16    nDstBitCount( pWriteAccess->GetBitCount() );
+        const sal_uInt16    nDstPaletteEntries( pWriteAccess->GetPaletteEntryCount() );
+        const BitmapColor*  pDstPalette( &pWriteAccess->GetPalette()[0] );
+        BYTE*               pDstBuffer = pWriteAccess->GetBuffer();
+
+        typedef PackedPixelIterator< const BYTE,
+            BYTE,
+            srcBitDepth,
+            true > SrcPixelIterator;
+        typedef PaletteImageAccessor< RGBVal, BYTE > SrcImageAccessor;
+
+        typedef PackedPixelIterator< BYTE,
+            BYTE,
+            dstBitDepth,
+            true > DstPixelIterator;
+        typedef PaletteImageAccessor< RGBVal, BYTE > DstImageAccessor;
+
+        const SrcPixelIterator aStartImage( pSrcBuffer,nSrcScanlineStride );
+        const SrcPixelIterator aEndImage( aStartImage + vigra::Diff2D(nSrcWidth,nSrcHeight) );
+
+        const DstPixelIterator aStartDstImage( pDstBuffer,nDstScanlineStride );
+        const DstPixelIterator aEndDstImage( aStartDstImage + vigra::Diff2D(nDstWidth,nDstHeight) );
+
+        vigra::resizeImageNoInterpolation(
+            //vigra::resizeImageLinearInterpolation(
+            vigra::make_triple(
+                aStartImage,
+                aEndImage,
+                SrcImageAccessor(
+                    pSrcPalette,
+                    nSrcPaletteEntries)),
+            vigra::make_triple(
+                aStartDstImage,
+                aEndDstImage,
+                DstImageAccessor(
+                    pDstPalette,
+                    nDstPaletteEntries)));
+    }
+
+    DrawBitmap( Point(), aDestBitmap );
+
+
+    Bitmap aDestBitmap2( Size(300,300),
+                        dstBitDepth );
+
+    {
+        ScopedBitmapReadAccess  pReadAccess( aSourceBitmap.AcquireReadAccess(),
+                                             aSourceBitmap );
+        ScopedBitmapWriteAccess pWriteAccess( aDestBitmap2.AcquireWriteAccess(),
+                                              aDestBitmap2 );
+
+        const sal_Int32     nSrcWidth( pReadAccess->Width() );
+        const sal_Int32     nSrcHeight( pReadAccess->Height() );
+        const bool          bSrcTopDown( pReadAccess->IsTopDown() );
+        const sal_uInt32    nSrcScanlineFormat( pReadAccess->GetScanlineFormat() );
+        const sal_uInt32    nSrcScanlineStride( pReadAccess->GetScanlineSize() );
+        const sal_uInt16    nSrcBitCount( pReadAccess->GetBitCount() );
+        const sal_uInt16    nSrcPaletteEntries( pReadAccess->GetPaletteEntryCount() );
+        const BitmapColor*  pSrcPalette( &pReadAccess->GetPalette()[0] );
+        const BYTE*         pSrcBuffer = pReadAccess->GetBuffer();
+
+        const sal_Int32     nDstWidth( pWriteAccess->Width() );
+        const sal_Int32     nDstHeight( pWriteAccess->Height() );
+        const bool          bDstTopDown( pWriteAccess->IsTopDown() );
+        const sal_uInt32    nDstScanlineFormat( pWriteAccess->GetScanlineFormat() );
+        const sal_uInt32    nDstScanlineStride( pWriteAccess->GetScanlineSize() );
+        const sal_uInt16    nDstBitCount( pWriteAccess->GetBitCount() );
+        const sal_uInt16    nDstPaletteEntries( pWriteAccess->GetPaletteEntryCount() );
+        const BitmapColor*  pDstPalette( &pWriteAccess->GetPalette()[0] );
+        BYTE*               pDstBuffer = pWriteAccess->GetBuffer();
+
+        typedef vigra::RGBValue< sal_uInt8 > RGBVal;
+        typedef PackedPixelIterator< const BYTE,
+            BYTE,
+            srcBitDepth,
+            true > SrcPixelIterator;
+        typedef PaletteImageAccessor< RGBVal,BYTE > SrcImageAccessor;
+
+        typedef PackedPixelIterator< BYTE,
+            BYTE,
+            dstBitDepth,
+            true > DstPixelIterator;
+        typedef PaletteImageAccessor< RGBVal,BYTE > DstImageAccessor;
+
+        const SrcPixelIterator aStartImage( pSrcBuffer,nSrcScanlineStride );
+        const SrcPixelIterator aEndImage( aStartImage + vigra::Diff2D(nSrcWidth,nSrcHeight) );
+
+        const DstPixelIterator aStartDstImage( pDstBuffer,nDstScanlineStride );
+        const DstPixelIterator aEndDstImage( aStartDstImage + vigra::Diff2D(nDstWidth,nDstHeight) );
+
+        vigra::resizeImageLinearInterpolation(
+            vigra::make_triple(
+                aStartImage,
+                aEndImage,
+                SrcImageAccessor(
+                    pSrcPalette,
+                    nSrcPaletteEntries)),
+            vigra::make_triple(
+                aStartDstImage,
+                aEndDstImage,
+                DstImageAccessor(
+                    pDstPalette,
+                    nDstPaletteEntries)));
+    }
+
+    DrawBitmap( Point(310,0), aDestBitmap2 );
+
+
+    Bitmap aDestBitmap3( Size(300,300),
+                         24 );
+
+    {
+        ScopedBitmapReadAccess  pReadAccess( aSourceBitmap.AcquireReadAccess(),
+                                             aSourceBitmap );
+        ScopedBitmapWriteAccess pWriteAccess( aDestBitmap3.AcquireWriteAccess(),
+                                              aDestBitmap3 );
+
+        const sal_Int32     nSrcWidth( pReadAccess->Width() );
+        const sal_Int32     nSrcHeight( pReadAccess->Height() );
+        const bool          bSrcTopDown( pReadAccess->IsTopDown() );
+        const sal_uInt32    nSrcScanlineFormat( pReadAccess->GetScanlineFormat() );
+        const sal_uInt32    nSrcScanlineStride( pReadAccess->GetScanlineSize() );
+        const sal_uInt16    nSrcBitCount( pReadAccess->GetBitCount() );
+        const sal_uInt16    nSrcPaletteEntries( pReadAccess->GetPaletteEntryCount() );
+        const BitmapColor*  pSrcPalette( &pReadAccess->GetPalette()[0] );
+        const BYTE*         pSrcBuffer = pReadAccess->GetBuffer();
+
+        const sal_Int32     nDstWidth( pWriteAccess->Width() );
+        const sal_Int32     nDstHeight( pWriteAccess->Height() );
+        const bool          bDstTopDown( pWriteAccess->IsTopDown() );
+        const sal_uInt32    nDstScanlineFormat( pWriteAccess->GetScanlineFormat() );
+        const sal_uInt32    nDstScanlineStride( pWriteAccess->GetScanlineSize() );
+        const sal_uInt16    nDstBitCount( pWriteAccess->GetBitCount() );
+        BYTE*               pDstBuffer = pWriteAccess->GetBuffer();
+
+        vigra::BasicImageView< RGBVal > aDestImage(
+            reinterpret_cast<RGBVal*>(pDstBuffer),
+            nDstWidth,
+            nDstHeight,
+            0 /*nDstScanlineStride should be an integer multiple of 4*/ );
+
+        typedef PackedPixelIterator< const BYTE,
+            BYTE,
+            srcBitDepth,
+            true > SrcPixelIterator;
+        typedef PaletteImageAccessor< RGBVal,BYTE > SrcImageAccessor;
+
+        const SrcPixelIterator aStartImage( pSrcBuffer,nSrcScanlineStride );
+        const SrcPixelIterator aEndImage( aStartImage + vigra::Diff2D(nSrcWidth,nSrcHeight) );
+
+        // resize bitmap
+        vigra::resizeImageSplineInterpolation(
+            vigra::make_triple(
+                aStartImage,
+                aEndImage,
+                SrcImageAccessor(
+                    pSrcPalette,
+                    nSrcPaletteEntries)),
+            vigra::destImageRange(aDestImage));
+
+        // add ellipse to bitmap
+        basegfx::B2DPolygon aPoly(
+            basegfx::tools::createPolygonFromEllipse(
+                basegfx::B2DPoint(150,150),
+                50, 80 ));
+        aPoly = basegfx::tools::adaptiveSubdivideByCount(aPoly);
+        makeRenderer( basegfx::B2DPolyPolygon( aPoly ),
+                      RGBVal(0,0xFF,0),
+                      RGBVal(0xFF,0xFF,0xFF),
+                      vigra::destImageRange(aDestImage) )->rasterConvert(
+                          basegfx::FillRule_NONZERO_WINDING_NUMBER );
+    }
+
+    DrawBitmap( Point(620,0), aDestBitmap3 );
+    DrawBitmap( Point(310,350), aSourceBitmap );
+}
+
+USHORT TestApp::Exception( USHORT nError )
+{
+    switch( nError & EXC_MAJORTYPE )
+    {
+        case EXC_RSCNOTLOADED:
+            Abort( String::CreateFromAscii( "Error: could not load language resources.\nPlease check your installation.\n" ) );
+            break;
+    }
+    return 0;
+}
+
+void TestApp::Main()
+{
+    //-------------------------------------------------
+    // create the global service-manager
+    //-------------------------------------------------
+    uno::Reference< lang::XMultiServiceFactory > xFactory;
+    try
+    {
+        uno::Reference< uno::XComponentContext > xCtx = ::cppu::defaultBootstrap_InitialComponentContext();
+        xFactory = uno::Reference< lang::XMultiServiceFactory >(  xCtx->getServiceManager(),
+                                                                  uno::UNO_QUERY );
+        if( xFactory.is() )
+            ::comphelper::setProcessServiceFactory( xFactory );
+    }
+    catch( uno::Exception& )
+    {
+    }
+
+    if( !xFactory.is() )
+    {
+        OSL_TRACE( "Could not bootstrap UNO, installation must be in disorder. Exiting.\n" );
+        exit( 1 );
+    }
+
+    // Create UCB.
+    uno::Sequence< uno::Any > aArgs( 2 );
+    aArgs[ 0 ] <<= rtl::OUString::createFromAscii( UCB_CONFIGURATION_KEY1_LOCAL );
+    aArgs[ 1 ] <<= rtl::OUString::createFromAscii( UCB_CONFIGURATION_KEY2_OFFICE );
+    ::ucb::ContentBroker::initialize( xFactory, aArgs );
+
+    TestWindow pWindow;
+    pWindow.Execute();
+
+    // clean up UCB
+    ::ucb::ContentBroker::deinitialize();
+}
+
+TestApp aDemoApp;
diff --git a/basebmp/test/export.map b/basebmp/test/export.map
new file mode 100644
index 000000000000..8cb6caacc51e
--- /dev/null
+++ b/basebmp/test/export.map
@@ -0,0 +1,42 @@
+#*************************************************************************
+#
+#   OpenOffice.org - a multi-platform office productivity suite
+#
+#   $RCSfile: export.map,v $
+#
+#   $Revision: 1.1 $
+#
+#   last change: $Author: thb $ $Date: 2006-05-31 09:49:44 $
+#
+#   The Contents of this file are made available subject to
+#   the terms of GNU Lesser General Public License Version 2.1.
+#
+#
+#     GNU Lesser General Public License Version 2.1
+#     =============================================
+#     Copyright 2005 by Sun Microsystems, Inc.
+#     901 San Antonio Road, Palo Alto, CA 94303, USA
+#
+#     This library is free software; you can redistribute it and/or
+#     modify it under the terms of the GNU Lesser General Public
+#     License version 2.1, as published by the Free Software Foundation.
+#
+#     This library is distributed in the hope that it will be useful,
+#     but WITHOUT ANY WARRANTY; without even the implied warranty of
+#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#     Lesser General Public License for more details.
+#
+#     You should have received a copy of the GNU Lesser General Public
+#     License along with this library; if not, write to the Free Software
+#     Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+#     MA  02111-1307  USA
+#
+#*************************************************************************
+
+UDK_3.1 {
+    global:
+        registerAllTestFunction;
+
+    local:
+        *;
+};
diff --git a/basebmp/test/filltest.cxx b/basebmp/test/filltest.cxx
new file mode 100644
index 000000000000..8a458cac573f
--- /dev/null
+++ b/basebmp/test/filltest.cxx
@@ -0,0 +1,113 @@
+// autogenerated file with codegen.pl
+
+#include <cppunit/simpleheader.hxx>
+
+#include <basegfx/vector/b2isize.hxx>
+#include <basegfx/range/b2drange.hxx>
+#include <basegfx/point/b2ipoint.hxx>
+#include <basegfx/polygon/b2dpolygon.hxx>
+#include <basegfx/polygon/b2dpolygontools.hxx>
+
+#include <basebmp/color.hxx>
+#include <basebmp/scanlineformats.hxx>
+#include <basebmp/bitmapdevice.hxx>
+#include <basebmp/debug.hxx>
+
+#include <iostream>
+#include <fstream>
+
+using namespace ::basebmp;
+
+namespace
+{
+/*
+  std::ofstream output("32bpp_test.dump");
+  debugDump( mpDevice32bpp, output );
+*/
+
+class FillTest : public CppUnit::TestFixture
+{
+private:
+    BitmapDeviceSharedPtr mpDevice1bpp;
+    BitmapDeviceSharedPtr mpDevice32bpp;
+
+    int countPixel( const BitmapDeviceSharedPtr& rDevice,
+                    Color                        checkColor ) const
+    {
+        int count(0);
+        const basegfx::B2ISize& rSize( rDevice->getSize() );
+        for( sal_Int32 y=0; y<rSize.getY(); ++y )
+            for( sal_Int32 x=0; x<rSize.getX(); ++x )
+                if( rDevice->getPixel( basegfx::B2IPoint(x,y) ) == checkColor )
+                    ++count;
+
+        return count;
+    }
+
+    void implTestRectFill(const BitmapDeviceSharedPtr& rDevice)
+    {
+        rDevice->clear(Color(0));
+
+        const basegfx::B2DRange   aRect(1,1,10,10);
+        const basegfx::B2DPolygon aRectPoly(
+            basegfx::tools::createPolygonFromRect( aRect ));
+
+        const Color aCol(0xFFFFFFFF);
+        rDevice->fillPolyPolygon( basegfx::B2DPolyPolygon(aRectPoly),
+                                  aCol,
+                                  DrawMode_PAINT );
+        const basegfx::B2IPoint aPt1(1,1);
+        CPPUNIT_ASSERT_MESSAGE("first pixel set",
+                               rDevice->getPixel(aPt1) == aCol);
+        const basegfx::B2IPoint aPt2(9,9);
+        CPPUNIT_ASSERT_MESSAGE("last pixel set",
+                               rDevice->getPixel(aPt2) == aCol);
+        const basegfx::B2IPoint aPt3(0,0);
+        CPPUNIT_ASSERT_MESSAGE("topmost pixel not set",
+                               rDevice->getPixel(aPt3) != aCol);
+        const basegfx::B2IPoint aPt4(10,10);
+        CPPUNIT_ASSERT_MESSAGE("bottommost pixel not set",
+                               rDevice->getPixel(aPt4) != aCol);
+
+        CPPUNIT_ASSERT_MESSAGE("number of rendered pixel is not 81",
+                               countPixel( rDevice, aCol ) == 81);
+    }
+
+public:
+    void setUp()
+    {
+        const basegfx::B2ISize aSize(11,11);
+        mpDevice1bpp = createBitmapDevice( aSize,
+                                           true,
+                                           Format::ONE_BIT_MSB_PAL );
+        mpDevice32bpp = createBitmapDevice( aSize,
+                                           true,
+                                           Format::THIRTYTWO_BIT_TC_MASK );
+    }
+
+    void testRectFill()
+    {
+        implTestRectFill( mpDevice1bpp );
+        implTestRectFill( mpDevice32bpp );
+    }
+
+    // Change the following lines only, if you add, remove or rename
+    // member functions of the current class,
+    // because these macros are need by auto register mechanism.
+
+    CPPUNIT_TEST_SUITE(FillTest);
+    CPPUNIT_TEST(testRectFill);
+    CPPUNIT_TEST_SUITE_END();
+};
+
+// -----------------------------------------------------------------------------
+CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(FillTest, "FillTest");
+}
+
+
+// -----------------------------------------------------------------------------
+
+// this macro creates an empty function, which will called by the RegisterAllFunctions()
+// to let the user the possibility to also register some functions by hand.
+//NOADDITIONAL;
+
diff --git a/basebmp/test/linetest.cxx b/basebmp/test/linetest.cxx
new file mode 100644
index 000000000000..12e82cd0de3a
--- /dev/null
+++ b/basebmp/test/linetest.cxx
@@ -0,0 +1,178 @@
+// autogenerated file with codegen.pl
+
+#include <cppunit/simpleheader.hxx>
+
+#include <basegfx/vector/b2isize.hxx>
+#include <basegfx/point/b2ipoint.hxx>
+
+#include <basebmp/color.hxx>
+#include <basebmp/scanlineformats.hxx>
+#include <basebmp/bitmapdevice.hxx>
+#include <basebmp/debug.hxx>
+
+#include <iostream>
+#include <fstream>
+
+using namespace ::basebmp;
+
+namespace
+{
+/*
+  std::ofstream output("32bpp_test.dump");
+  debugDump( mpDevice32bpp, output );
+*/
+
+class LineTest : public CppUnit::TestFixture
+{
+private:
+    BitmapDeviceSharedPtr mpDevice1bpp;
+    BitmapDeviceSharedPtr mpDevice32bpp;
+
+    int countPixel( const BitmapDeviceSharedPtr& rDevice,
+                    Color                        checkColor ) const
+    {
+        int count(0);
+        const basegfx::B2ISize& rSize( rDevice->getSize() );
+        for( sal_Int32 y=0; y<rSize.getY(); ++y )
+            for( sal_Int32 x=0; x<rSize.getX(); ++x )
+                if( rDevice->getPixel( basegfx::B2IPoint(x,y) ) == checkColor )
+                    ++count;
+
+        return count;
+    }
+
+    void implTestBasicDiagonalLines(const BitmapDeviceSharedPtr& rDevice)
+    {
+        rDevice->clear(Color(0));
+
+        const basegfx::B2IPoint aPt1(1,1);
+        const basegfx::B2IPoint aPt2(9,9);
+        const Color aCol(0xFFFFFFFF);
+        rDevice->drawLine( aPt1, aPt2, aCol, DrawMode_PAINT );
+        CPPUNIT_ASSERT_MESSAGE("first pixel set",
+                               rDevice->getPixel(aPt1) == aCol);
+        CPPUNIT_ASSERT_MESSAGE("last pixel set",
+                               rDevice->getPixel(aPt2) == aCol);
+        const basegfx::B2IPoint aPt3(0,0);
+        CPPUNIT_ASSERT_MESSAGE("topmost pixel not set",
+                               rDevice->getPixel(aPt3) != aCol);
+        const basegfx::B2IPoint aPt4(10,10);
+        CPPUNIT_ASSERT_MESSAGE("bottommost pixel not set",
+                               rDevice->getPixel(aPt4) != aCol);
+
+        CPPUNIT_ASSERT_MESSAGE("number of rendered pixel is not 9",
+                               countPixel( rDevice, aCol ) == 9);
+
+        rDevice->drawLine( aPt2, aPt1, aCol, DrawMode_PAINT );
+
+        CPPUNIT_ASSERT_MESSAGE("number of rendered pixel after "
+                               "reversed paint is not 9",
+                               countPixel( rDevice, aCol ) == 9);
+    }
+
+    void implTestBasicVerticalLines(const BitmapDeviceSharedPtr& rDevice)
+    {
+        rDevice->clear(Color(0));
+
+        const basegfx::B2IPoint aPt1(1,1);
+        const basegfx::B2IPoint aPt2(1,9);
+        const Color aCol(0xFFFFFFFF);
+        rDevice->drawLine( aPt1, aPt2, aCol, DrawMode_PAINT );
+        CPPUNIT_ASSERT_MESSAGE("first pixel set",
+                               rDevice->getPixel(aPt1) == aCol);
+        CPPUNIT_ASSERT_MESSAGE("last pixel set",
+                               rDevice->getPixel(aPt2) == aCol);
+        const basegfx::B2IPoint aPt3(0,0);
+        CPPUNIT_ASSERT_MESSAGE("topmost pixel not set",
+                               rDevice->getPixel(aPt3) != aCol);
+        const basegfx::B2IPoint aPt4(0,10);
+        CPPUNIT_ASSERT_MESSAGE("bottommost pixel not set",
+                               rDevice->getPixel(aPt4) != aCol);
+
+        CPPUNIT_ASSERT_MESSAGE("number of rendered pixel is not 9",
+                               countPixel( rDevice, aCol ) == 9);
+    }
+
+    // test pixel rounding (should always tend towards start point of
+    // the line)
+    void implTestTieBreaking(const BitmapDeviceSharedPtr& rDevice)
+    {
+        rDevice->clear(Color(0));
+
+        const basegfx::B2IPoint aPt1(1,1);
+        const basegfx::B2IPoint aPt2(3,2);
+        const Color aCol(0xFFFFFFFF);
+        rDevice->drawLine( aPt1, aPt2, aCol, DrawMode_PAINT );
+        CPPUNIT_ASSERT_MESSAGE("first pixel set",
+                               rDevice->getPixel(aPt1) == aCol);
+        CPPUNIT_ASSERT_MESSAGE("second pixel set",
+                               rDevice->getPixel(basegfx::B2IPoint(2,1)) == aCol);
+        CPPUNIT_ASSERT_MESSAGE("last pixel set",
+                               rDevice->getPixel(aPt2) == aCol);
+        CPPUNIT_ASSERT_MESSAGE("number of rendered pixel after "
+                               "reversed paint is not 3",
+                               countPixel( rDevice, aCol ) == 3);
+
+        rDevice->drawLine( aPt2, aPt1, aCol, DrawMode_PAINT );
+        CPPUNIT_ASSERT_MESSAGE("alternate second pixel set",
+                               rDevice->getPixel(basegfx::B2IPoint(2,2)) == aCol);
+
+        CPPUNIT_ASSERT_MESSAGE("number of rendered pixel after "
+                               "reversed paint is not 4",
+                               countPixel( rDevice, aCol ) == 4);
+    }
+
+public:
+    void setUp()
+    {
+        const basegfx::B2ISize aSize(11,11);
+        mpDevice1bpp = createBitmapDevice( aSize,
+                                           true,
+                                           Format::ONE_BIT_MSB_PAL );
+        mpDevice32bpp = createBitmapDevice( aSize,
+                                           true,
+                                           Format::THIRTYTWO_BIT_TC_MASK );
+    }
+
+    void testBasicDiagonalLines()
+    {
+        implTestBasicDiagonalLines( mpDevice1bpp );
+        implTestBasicDiagonalLines( mpDevice32bpp );
+    }
+
+    void testBasicVerticalLines()
+    {
+        implTestBasicVerticalLines( mpDevice1bpp );
+        //implTestBasicVerticalLines( mpDevice32bpp );
+    }
+
+    // test pixel rounding (should always tend towards start point of
+    // the line)
+    void testTieBreaking()
+    {
+        implTestTieBreaking( mpDevice1bpp );
+        implTestTieBreaking( mpDevice32bpp );
+    }
+
+    // Change the following lines only, if you add, remove or rename
+    // member functions of the current class,
+    // because these macros are need by auto register mechanism.
+
+    CPPUNIT_TEST_SUITE(LineTest);
+    CPPUNIT_TEST(testBasicDiagonalLines);
+    CPPUNIT_TEST(testBasicVerticalLines);
+    CPPUNIT_TEST(testTieBreaking);
+    CPPUNIT_TEST_SUITE_END();
+};
+
+// -----------------------------------------------------------------------------
+CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(LineTest, "LineTest");
+}
+
+
+// -----------------------------------------------------------------------------
+
+// this macro creates an empty function, which will called by the RegisterAllFunctions()
+// to let the user the possibility to also register some functions by hand.
+//NOADDITIONAL;
+
diff --git a/basebmp/test/makefile.mk b/basebmp/test/makefile.mk
new file mode 100644
index 000000000000..e6fec62d9df1
--- /dev/null
+++ b/basebmp/test/makefile.mk
@@ -0,0 +1,110 @@
+#*************************************************************************
+#
+#   OpenOffice.org - a multi-platform office productivity suite
+#
+#   $RCSfile: makefile.mk,v $
+#
+#   $Revision: 1.1 $
+#
+#   last change: $Author: thb $ $Date: 2006-05-31 09:49:45 $
+#
+#   The Contents of this file are made available subject to
+#   the terms of GNU Lesser General Public License Version 2.1.
+#
+#
+#     GNU Lesser General Public License Version 2.1
+#     =============================================
+#     Copyright 2005 by Sun Microsystems, Inc.
+#     901 San Antonio Road, Palo Alto, CA 94303, USA
+#
+#     This library is free software; you can redistribute it and/or
+#     modify it under the terms of the GNU Lesser General Public
+#     License version 2.1, as published by the Free Software Foundation.
+#
+#     This library is distributed in the hope that it will be useful,
+#     but WITHOUT ANY WARRANTY; without even the implied warranty of
+#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#     Lesser General Public License for more details.
+#
+#     You should have received a copy of the GNU Lesser General Public
+#     License along with this library; if not, write to the Free Software
+#     Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+#     MA  02111-1307  USA
+#
+#*************************************************************************
+
+PRJ=..
+
+PRJNAME=basebmp
+TARGET=tests
+TARGETTYPE=GUI
+
+ENABLE_EXCEPTIONS=TRUE
+
+# --- Settings -----------------------------------------------------
+
+.INCLUDE :  settings.mk
+
+.IF "$(debug)"!="" || "$(DEBUG)"!=""
+
+.IF "$(COM)"=="MSC"
+# disable inlining for MSVC
+CFLAGS += -Ob0
+.ENDIF
+
+.IF "$(COM)"=="GCC"
+# disable inlining for gcc
+CFLAGS += -fno-inline
+.ENDIF
+
+.ENDIF
+
+# --- Common ----------------------------------------------------------
+
+# BEGIN ----------------------------------------------------------------
+# auto generated Target:tests by codegen.pl 
+SHL1OBJS=  \
+    $(SLO)$/basictest.obj		\
+    $(SLO)$/filltest.obj		\
+    $(SLO)$/linetest.obj
+
+SHL1TARGET= tests
+SHL1STDLIBS= 	$(SALLIB)		 \
+                $(CPPUNITLIB)	 \
+                $(BASEGFXLIB)	 \
+                $(BASEBMPLIB)	
+
+SHL1IMPLIB= i$(SHL1TARGET)
+
+DEF1NAME    =$(SHL1TARGET)
+SHL1VERSIONMAP = export.map 
+
+# END ------------------------------------------------------------------
+
+APP2TARGET= bmpdemo
+
+APP2OBJS=	\
+    $(OBJ)$/bmpdemo.obj
+
+APP2STDLIBS=$(TOOLSLIB) 		\
+            $(COMPHELPERLIB)	\
+            $(BASEGFXLIB)	    \
+            $(BASEBMPLIB)	    \
+            $(CPPULIB)			\
+            $(CPPUHELPERLIB)	\
+            $(UCBHELPERLIB)		\
+            $(SALLIB)			\
+            $(VCLLIB)	
+
+.IF "$(GUI)"!="UNX"
+APP2DEF=	$(MISC)$/$(TARGET).def
+.ENDIF
+
+#------------------------------- All object files -------------------------------
+# do this here, so we get right dependencies
+SLOFILES=$(SHL1OBJS) 
+
+# --- Targets ------------------------------------------------------
+
+.INCLUDE : target.mk
+.INCLUDE : _cppunit.mk 
diff --git a/basebmp/util/basebmp.flt b/basebmp/util/basebmp.flt
new file mode 100644
index 000000000000..28a1dd1b65c6
--- /dev/null
+++ b/basebmp/util/basebmp.flt
@@ -0,0 +1,4 @@
+__CT
+Impl
+IMP
+internal
\ No newline at end of file
diff --git a/basebmp/util/makefile.mk b/basebmp/util/makefile.mk
new file mode 100644
index 000000000000..8f30bf61694b
--- /dev/null
+++ b/basebmp/util/makefile.mk
@@ -0,0 +1,74 @@
+#*************************************************************************
+#
+#   OpenOffice.org - a multi-platform office productivity suite
+#
+#   $RCSfile: makefile.mk,v $
+#
+#   $Revision: 1.1 $
+#
+#   last change: $Author: thb $ $Date: 2006-05-31 09:49:45 $
+#
+#   The Contents of this file are made available subject to
+#   the terms of GNU Lesser General Public License Version 2.1.
+#
+#
+#     GNU Lesser General Public License Version 2.1
+#     =============================================
+#     Copyright 2005 by Sun Microsystems, Inc.
+#     901 San Antonio Road, Palo Alto, CA 94303, USA
+#
+#     This library is free software; you can redistribute it and/or
+#     modify it under the terms of the GNU Lesser General Public
+#     License version 2.1, as published by the Free Software Foundation.
+#
+#     This library is distributed in the hope that it will be useful,
+#     but WITHOUT ANY WARRANTY; without even the implied warranty of
+#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#     Lesser General Public License for more details.
+#
+#     You should have received a copy of the GNU Lesser General Public
+#     License along with this library; if not, write to the Free Software
+#     Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+#     MA  02111-1307  USA
+#
+#*************************************************************************
+
+PRJ=..
+
+PRJNAME=basebmp
+TARGET=basebmp
+
+# --- Settings ---------------------------------------------------
+
+.INCLUDE :  settings.mk
+
+# --- Allgemein ---------------------------------------------------
+
+LIB1TARGET=$(SLB)$/basebmp.lib
+LIB1FILES=\
+    $(SLB)$/wrapper.lib
+
+SHL1TARGET= basebmp$(UPD)$(DLLPOSTFIX)
+SHL1IMPLIB= ibasebmp
+
+SHL1STDLIBS=\
+        $(SALLIB)	  \
+        $(BASEGFXLIB)
+
+SHL1DEF=	$(MISC)$/$(SHL1TARGET).def
+SHL1LIBS=	$(SLB)$/basebmp.lib
+
+DEF1NAME	=$(SHL1TARGET)
+DEF1DEPN	=$(MISC)$/$(SHL1TARGET).flt \
+        $(LIB1TARGET)
+
+DEF1DES		=BaseBMP
+DEFLIB1NAME	=basebmp
+
+# --- Targets -----------------------------------------------------------
+
+.INCLUDE :  target.mk
+
+$(MISC)$/$(SHL1TARGET).flt : makefile.mk
+    @+$(TYPE) $(TARGET).flt > $@
+