/* -*- 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 UNLESS_MERGELIBS(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: */