diff options
Diffstat (limited to 'include/vcl/graphictools.hxx')
| -rw-r--r-- | include/vcl/graphictools.hxx | 369 |
1 files changed, 369 insertions, 0 deletions
diff --git a/include/vcl/graphictools.hxx b/include/vcl/graphictools.hxx new file mode 100644 index 0000000000..ab2371bb79 --- /dev/null +++ b/include/vcl/graphictools.hxx @@ -0,0 +1,369 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_VCL_GRAPHICTOOLS_HXX +#define INCLUDED_VCL_GRAPHICTOOLS_HXX + +#include <vcl/dllapi.h> +#include <sal/types.h> +#include <tools/color.hxx> +#include <tools/poly.hxx> +#include <vcl/graph.hxx> + +#include <vector> + +class SvStream; + +/** 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 + }; + typedef ::std::vector< double > DashArray; + + SvtGraphicStroke(); + /** All in one constructor + + See accessor method descriptions for argument description + */ + SvtGraphicStroke( tools::Polygon aPath, + tools::PolyPolygon aStartArrow, + tools::PolyPolygon aEndArrow, + double fTransparency, + double fStrokeWidth, + CapType aCap, + JoinType aJoin, + double fMiterLimit, + DashArray&& rDashArray ); // TODO: Dash array offset (position where to start, see PS) + + // accessors + /// Query path to stroke + void getPath ( tools::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 ( tools::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 ( tools::PolyPolygon& ) const; + /** Get stroke transparency + + @return the transparency, ranging from 0.0 (opaque) to 1.0 (fully translucent) + */ + double getTransparency () const { return mfTransparency;} + /// Get width of the stroke + double getStrokeWidth () const { return mfStrokeWidth;} + /// Get the style in which open stroke ends are drawn + CapType getCapType () const { return maCapType;} + /// Get the style in which the stroke segments are joined + JoinType getJoinType () const { return maJoinType;} + /// Get the maximum length of mitered joins + double getMiterLimit () const { return mfMiterLimit;} + /// Get an array of "on" and "off" lengths for stroke dashing + void getDashArray ( DashArray& ) const; + + // mutators + /// Set path to stroke + void setPath ( const tools::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 tools::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 tools::PolyPolygon& ); + /// Affine scaling in both X and Y dimensions + void scale ( double fScaleX, double fScaleY ); + +private: + // friends + VCL_DLLPUBLIC friend SvStream& WriteSvtGraphicStroke( SvStream& rOStm, const SvtGraphicStroke& rClass ); + VCL_DLLPUBLIC friend SvStream& ReadSvtGraphicStroke( SvStream& rIStm, SvtGraphicStroke& rClass ); + + tools::Polygon maPath; + tools::PolyPolygon maStartArrow; + tools::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 vertical 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 class GradientType {Linear, Radial, Rectangular}; + /// 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( tools::PolyPolygon aPath, + 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, + sal_Int32 aGradientStepCount, // numbers of steps to render the gradient. gradientStepsInfinite means infinitely many. + Graphic aFillGraphic ); + + // accessors + /// Query path to fill + void getPath ( tools::PolyPolygon& ) const; + /// Get color used for solid fills + const Color& getFillColor () const { return maFillColor;} + /** Get stroke transparency + + @return the transparency, ranging from 0.0 (opaque) to 1.0 (fully translucent) + */ + double getTransparency () const { return mfTransparency;} + /// Get fill rule used + FillRule getFillRule () const { return maFillRule;} + /** 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 { return maFillType;} + /** 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; + + /** Query state of texture tiling + + @return true, if texture is tiled, false, if output only once. + */ + bool isTiling () const { return mbTiling;} + /// Get type of gradient used + GradientType getGradientType () const { return maGradientType;} + + /** 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; + + // mutators + /// Set path to fill + void setPath ( const tools::PolyPolygon& rPath ); + +private: + // friends + VCL_DLLPUBLIC friend SvStream& WriteSvtGraphicFill( SvStream& rOStm, const SvtGraphicFill& rClass ); + VCL_DLLPUBLIC friend SvStream& ReadSvtGraphicFill( SvStream& rIStm, SvtGraphicFill& rClass ); + + tools::PolyPolygon maPath; + Color maFillColor; + double mfTransparency; + FillRule maFillRule; + FillType maFillType; + Transform maFillTransform; + bool mbTiling; + HatchType maHatchType; + Color maHatchColor; + GradientType maGradientType; + Color maGradient1stColor; + Color maGradient2ndColor; + sal_Int32 maGradientStepCount; + Graphic maFillGraphic; +}; + +#endif // INCLUDED_VCL_GRAPHICTOOLS_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |