INTEGRATION: CWS hedaburemove01 (1.1.2); FILE ADDED

2007/02/09 16:10:51 vg 1.1.2.1: #72503# get rid of hedabu procedure: Moving headers to vcl/inc/vcl and correspondent necessary changes

4 files changed, 881 insertions, 0 deletions

diff --git a/vcl/inc/vcl/graph.h b/vcl/inc/vcl/graph.h
new file mode 100644
index 000000000000..eecf62bc426a
--- /dev/null
+++ b/vcl/inc/vcl/graph.h
@@ -0,0 +1,97 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: graph.h,v $
+ *
+ *  $Revision: 1.2 $
+ *
+ *  last change: $Author: vg $ $Date: 2007-04-11 17:55:21 $
+ *
+ *  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 _SV_GRAPH_H
+#define _SV_GRAPH_H
+
+#ifndef _VCL_DLLAPI_H
+#include <vcl/dllapi.h>
+#endif
+
+#ifndef _STRING_HXX
+#include <tools/string.hxx>
+#endif
+
+#ifndef _SV_SV_H
+#include <vcl/sv.h>
+#endif
+
+// ---------------
+// - GraphicType -
+// ---------------
+
+enum GraphicType
+{
+    GRAPHIC_NONE,
+    GRAPHIC_BITMAP,
+    GRAPHIC_GDIMETAFILE,
+    GRAPHIC_DEFAULT
+};
+
+// -----------------
+// - GraphicReader -
+// -----------------
+
+class ReaderData;
+
+class VCL_DLLPUBLIC GraphicReader
+{
+protected:
+
+    String          maUpperName;
+    ReaderData*     mpReaderData;
+    BOOL            mbIsReading;
+
+                    GraphicReader() :
+                        mpReaderData( NULL ),
+                        mbIsReading( FALSE ) {}
+
+public:
+
+    virtual         ~GraphicReader();
+
+    const String&   GetUpperFilterName() const { return maUpperName; }
+    ReaderData*     GetReaderData() const { return mpReaderData; }
+    BOOL            IsReading() const { return mbIsReading; }
+
+    // TODO: when incompatible changes are possible again
+    // the preview size hint should be redone
+    BOOL            IsPreviewModeEnabled() const;
+    void            DisablePreviewMode();
+    void            SetPreviewSize( const Size& );
+    Size            GetPreviewSize() const;
+};
+
+#endif // _SV_GRAPH_H
diff --git a/vcl/inc/vcl/graph.hxx b/vcl/inc/vcl/graph.hxx
new file mode 100644
index 000000000000..d6a33a35258b
--- /dev/null
+++ b/vcl/inc/vcl/graph.hxx
@@ -0,0 +1,217 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: graph.hxx,v $
+ *
+ *  $Revision: 1.2 $
+ *
+ *  last change: $Author: vg $ $Date: 2007-04-11 17:55:29 $
+ *
+ *  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 _SV_GRAPH_HXX
+#define _SV_GRAPH_HXX
+
+#ifndef _STREAM_HXX
+#include <tools/stream.hxx>
+#endif
+
+#ifndef _VCL_DLLAPI_H
+#include <vcl/dllapi.h>
+#endif
+
+#ifndef _SV_SV_H
+#include <vcl/sv.h>
+#endif
+#ifndef _SV_BITMAP_HXX
+#include <vcl/bitmap.hxx>
+#endif
+#ifndef _SV_BITMAPEX_HXX
+#include <vcl/bitmapex.hxx>
+#endif
+#ifndef _SV_ANIMATE_HXX
+#include <vcl/animate.hxx>
+#endif
+#ifndef _SV_GDIMTF_HXX
+#include <vcl/gdimtf.hxx>
+#endif
+#ifndef _SV_GRAPH_H
+#include <vcl/graph.h>
+#endif
+#ifndef _GFXLINK_HXX
+#include <vcl/gfxlink.hxx>
+#endif
+#ifndef _COM_SUN_STAR_UNO_REFERENCE_HXX_
+#include <com/sun/star/uno/Reference.hxx>
+#endif
+
+namespace com { namespace sun { namespace star { namespace graphic { class XGraphic;} } } }
+
+// -----------
+// - Graphic -
+// -----------
+
+class   ImpGraphic;
+class   OutputDevice;
+class   Font;
+class   GfxLink;
+
+class VCL_DLLPUBLIC Graphic : public SvDataCopyStream
+{
+private:
+
+    ImpGraphic*         mpImpGraphic;
+
+//#if 0 // _SOLAR__PRIVATE
+
+public:
+
+    SAL_DLLPRIVATE void         ImplTestRefCount();
+    SAL_DLLPRIVATE ImpGraphic*  ImplGetImpGraphic() const { return mpImpGraphic; }
+
+//#endif
+
+public:
+
+                        TYPEINFO();
+
+                        Graphic();
+                        Graphic( const Graphic& rGraphic );
+                        Graphic( const Bitmap& rBmp );
+                        Graphic( const BitmapEx& rBmpEx );
+                        Graphic( const Animation& rAnimation );
+                        Graphic( const GDIMetaFile& rMtf );
+                        Graphic( const ::com::sun::star::uno::Reference< ::com::sun::star::graphic::XGraphic >& rxGraphic );
+    virtual             ~Graphic();
+
+    Graphic&            operator=( const Graphic& rGraphic );
+    BOOL                operator==( const Graphic& rGraphic ) const;
+    BOOL                operator!=( const Graphic& rGraphic ) const;
+    BOOL                operator!() const;
+
+    void                Clear();
+
+    GraphicType         GetType() const;
+    void                SetDefaultType();
+    BOOL                IsSupportedGraphic() const;
+
+    BOOL                IsTransparent() const;
+    BOOL                IsAlpha() const;
+    BOOL                IsAnimated() const;
+
+    Bitmap              GetBitmap() const;
+    Bitmap              GetBitmap( const Size* pSizePixel ) const;
+    BitmapEx            GetBitmapEx() const;
+    BitmapEx            GetBitmapEx( const Size* pSizePixel ) const;
+    Bitmap              GetUnlimitedBitmap( const Size* pSizePixel ) const;
+    BitmapEx            GetUnlimitedBitmapEx( const Size* pSizePixel ) const;
+    Animation           GetAnimation() const;
+    const GDIMetaFile&  GetGDIMetaFile() const;
+
+    ::com::sun::star::uno::Reference< ::com::sun::star::graphic::XGraphic > GetXGraphic() const;
+
+    Size                GetPrefSize() const;
+    void                SetPrefSize( const Size& rPrefSize );
+
+    MapMode             GetPrefMapMode() const;
+    void                SetPrefMapMode( const MapMode& rPrefMapMode );
+
+    Size                GetSizePixel( const OutputDevice* pRefDevice = NULL ) const;
+
+    ULONG               GetSizeBytes() const;
+
+    void                Draw( OutputDevice* pOutDev,
+                              const Point& rDestPt ) const;
+    void                Draw( OutputDevice* pOutDev,
+                              const Point& rDestPt,
+                              const Size& rDestSize ) const;
+    static void         Draw( OutputDevice* pOutDev, const String& rText,
+                              Font& rFont, const Bitmap& rBitmap,
+                              const Point& rDestPt, const Size& rDestSize );
+
+    void                StartAnimation( OutputDevice* pOutDev,
+                                        const Point& rDestPt,
+                                        long nExtraData = 0L,
+                                        OutputDevice* pFirstFrameOutDev = NULL );
+    void                StartAnimation( OutputDevice* pOutDev,
+                                        const Point& rDestPt,
+                                        const Size& rDestSize,
+                                        long nExtraData = 0L,
+                                        OutputDevice* pFirstFrameOutDev = NULL );
+    void                StopAnimation( OutputDevice* pOutputDevice = NULL,
+                                       long nExtraData = 0L );
+
+    void                SetAnimationNotifyHdl( const Link& rLink );
+    Link                GetAnimationNotifyHdl() const;
+
+    ULONG               GetAnimationLoopCount() const;
+    void                ResetAnimationLoopCount();
+
+    List*               GetAnimationInfoList() const;
+
+    ULONG               GetChecksum() const;
+
+public:
+
+    GraphicReader*      GetContext();
+    void                SetContext( GraphicReader* pReader );
+
+public:
+
+    static USHORT       GetGraphicsCompressMode( SvStream& rIStm );
+
+    void                SetDocFileName( const String& rName, ULONG nFilePos );
+    const String&       GetDocFileName() const;
+    ULONG               GetDocFilePos() const;
+
+    BOOL                ReadEmbedded( SvStream& rIStream, BOOL bSwap = FALSE );
+    BOOL                WriteEmbedded( SvStream& rOStream );
+
+    BOOL                SwapOut();
+    BOOL                SwapOut( SvStream* pOStm );
+    BOOL                SwapIn();
+    BOOL                SwapIn( SvStream* pIStm );
+    BOOL                IsSwapOut() const;
+
+    void                SetLink( const GfxLink& );
+    GfxLink             GetLink();
+    BOOL                IsLink() const;
+
+    BOOL                ExportNative( SvStream& rOStream ) const;
+
+    friend VCL_DLLPUBLIC SvStream&    operator<<( SvStream& rOStream, const Graphic& rGraphic );
+    friend VCL_DLLPUBLIC SvStream&    operator>>( SvStream& rIStream, Graphic& rGraphic );
+
+public:
+
+    virtual void        Load( SvStream& );
+    virtual void        Save( SvStream& );
+    virtual void        Assign( const SvDataCopyStream& );
+};
+
+#endif  // _SV_GRAPH_HXX
+
diff --git a/vcl/inc/vcl/graphictools.hxx b/vcl/inc/vcl/graphictools.hxx
new file mode 100644
index 000000000000..3933f7da7e54
--- /dev/null
+++ b/vcl/inc/vcl/graphictools.hxx
@@ -0,0 +1,490 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: graphictools.hxx,v $
+ *
+ *  $Revision: 1.2 $
+ *
+ *  last change: $Author: vg $ $Date: 2007-04-11 17:55:39 $
+ *
+ *  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 _VCL_GRAPHICTOOLS_HXX_
+#define _VCL_GRAPHICTOOLS_HXX_
+
+#ifndef _VCL_DLLAPI_H
+#include <vcl/dllapi.h>
+#endif
+
+#ifndef _SAL_TYPES_H_
+#include <sal/types.h>
+#endif
+
+#ifndef _RTL_STRING_HXX_
+#include <rtl/string.hxx>
+#endif
+
+#ifndef _TOOLS_COLOR_HXX
+#include <tools/color.hxx>
+#endif
+
+#ifndef _TL_POLY_HXX
+#include <tools/poly.hxx>
+#endif
+
+#ifndef _STREAM_HXX
+#include <tools/stream.hxx>
+#endif
+
+#ifndef _SV_GRAPH_HXX
+#include <vcl/graph.hxx>
+#endif
+
+#ifndef INCLUDED_MEMORY
+#include <memory>
+#define INCLUDED_MEMORY
+#endif
+
+#ifndef INCLUDED_VECTOR
+#include <vector>
+#define INCLUDED_VECTOR
+#endif
+
+/** Encapsulates geometry and associated attributes of a graphical 'pen stroke'
+
+    @attention Widespread use is deprecated. See declarations above
+    for the way to go. Especially the copied enums from svx/xenum.hxx
+    are troublesome.
+
+    Use this class to store geometry and attributes of a graphical
+    'pen stroke', such as pen width, dashing etc. The geometry is the
+    so-called 'path' along which the stroke is traced, with the given
+    pen width. The cap type determines how the open ends of the path
+    should be drawn. If the geometry consists of more than one
+    segment, the join type determines in which way the segments are
+    joined.
+ */
+class VCL_DLLPUBLIC SvtGraphicStroke
+{
+public:
+    /// Style for open stroke ends
+    enum CapType
+    {
+        /// No additional cap
+        capButt=0,
+        /// Half-round cap at the line end, the center lying at the end point
+        capRound,
+        /// Half-square cap at the line end, the center lying at the end point
+        capSquare
+    };
+    /// Style for joins of individual stroke segments
+    enum JoinType
+    {
+        /// Extend segment edges, until they cross
+        joinMiter=0,
+        /// Connect segments by a filled round arc
+        joinRound,
+        /// Connect segments by a direct straight line
+        joinBevel,
+        /// Perform no join, leads to visible gaps between thick line segments
+        joinNone
+    };
+    enum
+    {
+        /// Width of stroke start/end arrow to exactly fit the joining stroke
+        normalizedArrowWidth=65536
+    };
+    typedef ::std::vector< double > DashArray;
+
+    SvtGraphicStroke();
+    /** All in one constructor
+
+        See accessor method descriptions for argument description
+     */
+    SvtGraphicStroke( const Polygon&        rPath,
+                      const PolyPolygon&    rStartArrow,
+                      const PolyPolygon&    rEndArrow,
+                      double                fTransparency,
+                      double                fStrokeWidth,
+                      CapType               aCap,
+                      JoinType              aJoin,
+                      double                fMiterLimit,
+                      const DashArray&      rDashArray  );      // TODO: Dash array offset (position where to start, see PS)
+
+    // accessors
+    /// Query path to stroke
+    void            getPath             ( Polygon& ) const;
+    /** Get the polygon that is put at the start of the line
+
+        The polygon is in a special normalized position: the center of
+        the stroked path will meet the given polygon at (0,0) from
+        negative y values. Thus, an arrow would have its baseline on
+        the x axis, going upwards to positive y values. Furthermore,
+        the polygon is also scaled in a special way: the width of the
+        joining stroke is defined to be
+        SvtGraphicStroke::normalizedArrowWidth (0x10000), i.e. ranging
+        from x=-0x8000 to x=0x8000. So, if the arrow does have this
+        width, it has to fit every stroke with every stroke width
+        exactly.
+     */
+    void            getStartArrow       ( PolyPolygon& ) const;
+    /** Get the polygon that is put at the end of the line
+
+        The polygon is in a special normalized position, and already
+        scaled to the desired size: the center of the stroked path
+        will meet the given polygon at (0,0) from negative y
+        values. Thus, an arrow would have its baseline on the x axis,
+        going upwards to positive y values. Furthermore, the polygon
+        is also scaled in a special way: the width of the joining
+        stroke is defined to be SvtGraphicStroke::normalizedArrowWidth
+        (0x10000), i.e. ranging from x=-0x8000 to x=0x8000. So, if the
+        arrow does have this width, it has to fit every stroke with
+        every stroke width exactly.
+     */
+    void            getEndArrow         ( PolyPolygon& ) const;
+    /** Get stroke transparency
+
+        @return the transparency, ranging from 0.0 (opaque) to 1.0 (fully translucent)
+     */
+    double          getTransparency     () const;
+    /// Get width of the stroke
+    double          getStrokeWidth      () const;
+    /// Get the style in which open stroke ends are drawn
+    CapType         getCapType          () const;
+    /// Get the style in which the stroke segments are joined
+    JoinType        getJoinType         () const;
+    /// Get the maximum length of mitered joins
+    double          getMiterLimit       () const;
+    /// Get an array of "on" and "off" lengths for stroke dashing
+    void            getDashArray        ( DashArray& ) const;
+    /// Query a textual representation of the object's content
+    ::rtl::OString  toString            () const;
+
+    // mutators
+    /// Set path to stroke
+    void    setPath             ( const Polygon& );
+    /** Set the polygon that is put at the start of the line
+
+        The polygon has to be in a special normalized position, and
+        already scaled to the desired size: the center of the stroked
+        path will meet the given polygon at (0,0) from negative y
+        values. Thus, an arrow would have its baseline on the x axis,
+        going upwards to positive y values. Furthermore, the polygon
+        also has to be scaled appropriately: the width of the joining
+        stroke is defined to be SvtGraphicStroke::normalizedArrowWidth
+        (0x10000), i.e. ranging from x=-0x8000 to x=0x8000. If your
+        arrow does have this width, it will fit every stroke with
+        every stroke width exactly.
+     */
+    void    setStartArrow       ( const PolyPolygon& );
+    /** Set the polygon that is put at the end of the line
+
+        The polygon has to be in a special normalized position, and
+        already scaled to the desired size: the center of the stroked
+        path will meet the given polygon at (0,0) from negative y
+        values. Thus, an arrow would have its baseline on the x axis,
+        going upwards to positive y values. Furthermore, the polygon
+        also has to be scaled appropriately: the width of the joining
+        stroke is defined to be SvtGraphicStroke::normalizedArrowWidth
+        (0x10000), i.e. ranging from x=-0x8000 to x=0x8000. If your
+        arrow does have this width, it will fit every stroke with
+        every stroke width exactly.
+     */
+    void    setEndArrow         ( const PolyPolygon& );
+    /** Set stroke transparency
+
+        @param fTrans
+        The transparency, ranging from 0.0 (opaque) to 1.0 (fully translucent)
+     */
+    void    setTransparency     ( double fTrans );
+    /// Set width of the stroke
+    void    setStrokeWidth      ( double );
+    /// Set the style in which open stroke ends are drawn
+    void    setCapType          ( CapType );
+    /// Set the style in which the stroke segments are joined
+    void    setJoinType         ( JoinType );
+    /// Set the maximum length of mitered joins
+    void    setMiterLimit       ( double );
+    /// Set the array of "on" and "off" lengths for stroke dashing
+    void    setDashArray        ( const DashArray& );
+
+private:
+    // friends
+    VCL_DLLPUBLIC friend SvStream& operator<<( SvStream& rOStm, const SvtGraphicStroke& rClass );
+    VCL_DLLPUBLIC friend SvStream& operator>>( SvStream& rIStm, SvtGraphicStroke& rClass );
+
+    Polygon         maPath;
+    PolyPolygon     maStartArrow;
+    PolyPolygon     maEndArrow;
+    double          mfTransparency;
+    double          mfStrokeWidth;
+    CapType         maCapType;
+    JoinType        maJoinType;
+    double          mfMiterLimit;
+    DashArray       maDashArray;
+};
+
+/** Encapsulates geometry and associated attributes of a filled area
+
+    @attention Widespread use is deprecated. See declarations above
+    for the way to go. Especially the copied enums from svx/xenum.hxx
+    is troublesome.
+
+    Use this class to store geometry and attributes of a filled area,
+    such as fill color, transparency, texture or hatch.  The geometry
+    is the so-called 'path', whose inner area will get filled
+    according to the attributes set. If the path is intersecting, or
+    one part of the path is lying fully within another part, then the
+    fill rule determines which parts are filled and which are not.
+ */
+class VCL_DLLPUBLIC SvtGraphicFill
+{
+public:
+    /// Type of fill algorithm used
+    enum FillRule
+    {
+        /** Non-zero winding rule
+
+            Fill shape scanline-wise. Starting at the left, determine
+            the winding number as follows: every segment crossed that
+            runs counter-clockwise adds one to the winding number,
+            every segment crossed that runs clockwise subtracts
+            one. The part of the scanline where the winding number is
+            non-zero gets filled.
+         */
+        fillNonZero=0,
+        /** Even-odd fill rule
+
+            Fill shape scanline-wise. Starting at the left, count the
+            number of segments crossed. If this number is odd, the
+            part of the scanline is filled, otherwise not.
+         */
+        fillEvenOdd
+    };
+    /// Type of filling used
+    enum FillType
+    {
+        /// Fill with a specified solid color
+        fillSolid=0,
+        /// Fill with the specified gradient
+        fillGradient,
+        /// Fill with the specified hatch
+        fillHatch,
+        /// Fill with the specified texture (a Graphic object)
+        fillTexture
+    };
+    /// Type of hatching used
+    enum HatchType
+    {
+        /// horizontal parallel lines, one unit apart
+        hatchSingle=0,
+        /// horizontal and verticall orthogonally crossing lines, one unit apart
+        hatchDouble,
+        /// three crossing lines, like HatchType::hatchDouble, but
+        /// with an additional diagonal line, rising to the upper
+        /// right corner. The first diagonal line goes through the
+        /// upper left corner, the other are each spaced a unit apart.
+        hatchTriple
+    };
+    /// Type of gradient used
+    enum GradientType {gradientLinear=0, gradientRadial, gradientRectangular};
+    /// Special values for gradient step count
+    enum { gradientStepsInfinite=0 };
+    /** Homogeneous 2D transformation matrix
+
+        This is a 2x3 matrix representing an affine transformation on
+        the R^2, in the usual C/C++ row major form. It is structured as follows:
+        <pre>
+        a b t_x
+        c d t_y
+        0 0 1
+        </pre>
+        where the lowest line is not stored in the matrix, since it is
+        constant. Variables t_x and t_y contain translational
+        components, a to d rotation, scale and shear (for details,
+        look up your favorite linear algebra/computer graphics book).
+     */
+    struct VCL_DLLPUBLIC Transform
+    {
+        enum { MatrixSize=6 };
+        Transform();
+        double matrix[MatrixSize];
+    };
+
+    SvtGraphicFill();
+    /** All in one constructor
+
+        See accessor method descriptions for argument description
+     */
+    SvtGraphicFill( const PolyPolygon&  rPath,
+                    Color               aFillColor,
+                    double              fTransparency,
+                    FillRule            aFillRule,
+                    FillType            aFillType,              // TODO: Multitexturing
+                    const Transform&    aFillTransform,
+                    bool                bTiling,
+                    HatchType           aHatchType,             // TODO: vector of directions and start points
+                    Color               aHatchColor,
+                    GradientType        aGradientType,          // TODO: Transparent gradients (orthogonal to normal ones)
+                    Color               aGradient1stColor,      // TODO: vector of colors and offsets
+                    Color               aGradient2ndColor,
+                    int                 aGradientStepCount,     // numbers of steps to render the gradient. gradientStepsInfinite means infinitely many.
+                    const Graphic&      aFillGraphic );
+
+    // accessors
+    /// Query path to fill
+    void            getPath             ( PolyPolygon& ) const;
+    /// Get color used for solid fills
+    Color           getFillColor        () const;
+    /** Get stroke transparency
+
+        @return the transparency, ranging from 0.0 (opaque) to 1.0 (fully translucent)
+     */
+    double          getTransparency     () const;
+    /// Get fill rule used
+    FillRule        getFillRule         () const;
+    /** Get fill type used
+
+        Currently, only one of the fill types can be used
+        simultaneously. If you specify e.g. FillRule::fillGradient,
+        hatching, texture and solid fill color are ignored.
+     */
+    FillType        getFillType         () const;
+    /** Get transformation applied to hatch, gradient or texture during fill
+
+        A fill operation generally starts at the top left position of
+        the object's bounding box. At that position (if tiling is on,
+        also all successive positions), the specified fill graphic is
+        rendered, after applying the fill transformation to it. For
+        example, if the fill transformation contains a translation,
+        the fill graphic is rendered at the object's bounding box's
+        top left corner plus the translation components.
+
+     */
+    void            getTransform        ( Transform& ) const;
+    /// deprecated
+    bool            IsTiling            () const;
+    /** Query state of texture tiling
+
+        @return true, if texture is tiled, false, if output only once.
+     */
+    bool            isTiling            () const;
+    /// Get type of hatch used
+    HatchType       getHatchType        () const;
+    /// Get color used for drawing the hatch
+    Color           getHatchColor       () const;
+    /// Get type of gradient used
+    GradientType    getGradientType     () const;
+    /// Get start color of the gradient
+    Color           getGradient1stColor () const;
+    /// Get end color of the gradient
+    Color           getGradient2ndColor () const;
+    /** Get the numbers of steps to render the gradient.
+
+        @return the step count. gradientStepsInfinite means infinitely many.
+    */
+    int             getGradientStepCount() const;
+    /** Get the texture graphic used
+
+        The Graphic object returned is used to fill the geometry, if
+        the FillType is fillTexture. The Graphic object is always
+        assumed to be of size 1x1, the transformation is used to scale
+        it to the appropriate size.
+     */
+    void            getGraphic          ( Graphic& ) const;
+    /// Query a textual representation of the object's content
+    ::rtl::OString  toString            () const;
+
+    // mutators
+    /// Set path to fill
+    void    setPath             ( const PolyPolygon& rPath );
+    /// Set color used for solid fills
+    void    setFillColor        ( Color aFillColor );
+    /** Set stroke transparency
+
+        @param fTransparency
+        The transparency, ranging from 0.0 (opaque) to 1.0 (fully translucent)
+     */
+    void    setTransparency     ( double fTransparency );
+    /// Set fill rule used
+    void    setFillRule         ( FillRule aFillRule );
+    /** Set fill type used
+
+        Currently, only one of the fill types can be used
+        simultaneously. If you specify e.g. FillRule::fillGradient,
+        hatching, texture and solid fill color are ignored.
+     */
+    void    setFillType         ( FillType aFillType );
+    /// Set transformation applied to hatch, gradient or texture during fill
+    void    setTransform        ( const Transform& pTransform );
+    /** Set state of texture tiling
+
+        @param bTiling
+        If set to true, texture is tiled, if set to false, texture is output only once.
+     */
+    void    setTiling           ( bool bTiling = true );
+    /// Set type of hatch used
+    void    setHatchType        ( HatchType aHatchType );
+    /// Set color used for drawing the hatch
+    void    setHatchColor       ( Color aHatchColor );
+    /// Set type of gradient used
+    void    setGradientType     ( GradientType aGradType );
+    /// Set start color of the gradient
+    void    setGradient1stColor ( Color aColor );
+    /// Set end color of the gradient
+    void    setGradient2ndColor ( Color aColor );
+    /** Set the numbers of steps to render the gradient.
+
+        @param aCount
+        The step count. gradientStepsInfinite means use infinitely many.
+    */
+    void    setGradientStepCount( int aCount );
+    /// Set the texture graphic used
+    void    setGraphic          ( const Graphic& rGraphic );
+
+private:
+    // friends
+    VCL_DLLPUBLIC friend SvStream& operator<<( SvStream& rOStm, const SvtGraphicFill& rClass );
+    VCL_DLLPUBLIC friend SvStream& operator>>( SvStream& rIStm, SvtGraphicFill& rClass );
+
+    PolyPolygon     maPath;
+    Color           maFillColor;
+    double          mfTransparency;
+    FillRule        maFillRule;
+    FillType        maFillType;
+    Transform       maFillTransform;
+    bool            mbTiling;
+    HatchType       maHatchType;
+    Color           maHatchColor;
+    GradientType    maGradientType;
+    Color           maGradient1stColor;
+    Color           maGradient2ndColor;
+    int             maGradientStepCount;
+    Graphic         maFillGraphic;
+};
+
+#endif /* _VCL_GRAPHICTOOLS_HXX_ */
diff --git a/vcl/inc/vcl/group.hxx b/vcl/inc/vcl/group.hxx
new file mode 100644
index 000000000000..26f6ad0c56ca
--- /dev/null
+++ b/vcl/inc/vcl/group.hxx
@@ -0,0 +1,77 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: group.hxx,v $
+ *
+ *  $Revision: 1.2 $
+ *
+ *  last change: $Author: vg $ $Date: 2007-04-11 17:56:01 $
+ *
+ *  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 _SV_GROUP_HXX
+#define _SV_GROUP_HXX
+
+#ifndef _SV_SV_H
+#include <vcl/sv.h>
+#endif
+#ifndef _VCL_DLLAPI_H
+#include <vcl/dllapi.h>
+#endif
+
+#ifndef _SV_CTRL_HXX
+#include <vcl/ctrl.hxx>
+#endif
+
+// ------------
+// - GroupBox -
+// ------------
+
+class VCL_DLLPUBLIC GroupBox : public Control
+{
+private:
+    using Window::ImplInit;
+    SAL_DLLPRIVATE void     ImplInit( Window* pParent, WinBits nStyle );
+    SAL_DLLPRIVATE WinBits  ImplInitStyle( WinBits nStyle );
+    SAL_DLLPRIVATE void     ImplInitSettings( BOOL bFont, BOOL bForeground, BOOL bBackground );
+    SAL_DLLPRIVATE void     ImplDraw( OutputDevice* pDev, ULONG nDrawFlags,
+                                      const Point& rPos, const Size& rSize, bool bLayout = false );
+
+    virtual void    FillLayoutData() const;
+
+public:
+                    GroupBox( Window* pParent, WinBits nStyle = 0 );
+                    GroupBox( Window* pParent, const ResId& rResId );
+
+    virtual void    Paint( const Rectangle& rRect );
+    virtual void    Draw( OutputDevice* pDev, const Point& rPos, const Size& rSize, ULONG nFlags );
+    virtual void    Resize();
+    virtual void    StateChanged( StateChangedType nType );
+    virtual void    DataChanged( const DataChangedEvent& rDCEvt );
+};
+
+#endif  // _SV_GROUP_HXX