graphictools.hxx

Go to the documentation of this file.

/* -*- 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;

class VCL_DLLPUBLIC SvtGraphicStroke
{
public:
    enum CapType
    {
        capButt=0,
        capRound,
        capSquare
    };
    enum JoinType
    {
        joinMiter=0,
        joinRound,
        joinBevel,
        joinNone
    };
    typedef ::std::vector< double > DashArray;

    SvtGraphicStroke();
    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
    void            getPath             ( tools::Polygon& ) const;
    void            getStartArrow       ( tools::PolyPolygon& ) const;
    void            getEndArrow         ( tools::PolyPolygon& ) const;
    double          getTransparency     () const { return mfTransparency;}
    double          getStrokeWidth      () const { return mfStrokeWidth;}
    CapType         getCapType          () const { return maCapType;}
    JoinType        getJoinType         () const { return maJoinType;}
    double          getMiterLimit       () const { return mfMiterLimit;}
    void            getDashArray        ( DashArray& ) const;

    // mutators
    void    setPath             ( const tools::Polygon& );
    void    setStartArrow       ( const tools::PolyPolygon& );
    void    setEndArrow         ( const tools::PolyPolygon& );
    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;
};

class VCL_DLLPUBLIC SvtGraphicFill
{
public:
    enum FillRule
    {
        fillNonZero=0,
        fillEvenOdd
    };
    enum FillType
    {
        fillSolid=0,
        fillGradient,
        fillHatch,
        fillTexture
    };
    enum HatchType
    {
        hatchSingle=0,
        hatchDouble,
        hatchTriple
    };
    enum class GradientType {Linear, Radial, Rectangular};
    enum { gradientStepsInfinite=0 };
    struct VCL_DLLPUBLIC Transform
    {
        enum { MatrixSize=6 };
        Transform();
        double matrix[MatrixSize];
    };

    SvtGraphicFill();
    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
    void            getPath             ( tools::PolyPolygon& ) const;
    const Color&    getFillColor        () const { return maFillColor;}
    double          getTransparency     () const { return mfTransparency;}
    FillRule        getFillRule         () const { return maFillRule;}
    FillType        getFillType         () const { return maFillType;}
    void            getTransform        ( Transform& ) const;

    bool            isTiling            () const { return mbTiling;}
    GradientType    getGradientType     () const { return maGradientType;}

    void            getGraphic          ( Graphic& ) const;

    // mutators
    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: */