bd7cf39159
Change-Id: Ic43e02576454e3ee174304db350659dd113a1d5f Reviewed-on: https://gerrit.libreoffice.org/c/core/+/123186 Tested-by: Jenkins Reviewed-by: Noel Grandin <noel.grandin@collabora.co.uk>
369 lines
15 KiB
C++
369 lines
15 KiB
C++
/* -*- 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( const tools::Polygon& rPath,
|
|
const tools::PolyPolygon& rStartArrow,
|
|
const tools::PolyPolygon& rEndArrow,
|
|
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( const tools::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,
|
|
sal_Int32 aGradientStepCount, // numbers of steps to render the gradient. gradientStepsInfinite means infinitely many.
|
|
const 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: */
|