office-gobmx/include/drawinglayer/primitive2d/polypolygonprimitive2d.hxx
Armin Le Grand 5aee0c13cc Resolves: #i121532# enhanced visualisation of text edit&selection
D&D overhauled

(cherry picked from commit c6e63b6bbb6b4a63fe1302de57fc32cd28432378)

Conflicts:
	drawinglayer/inc/drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx
	drawinglayer/inc/drawinglayer/primitive2d/polypolygonprimitive2d.hxx
	drawinglayer/inc/drawinglayer/processor2d/linegeometryextractor2d.hxx
	drawinglayer/source/primitive2d/polypolygonprimitive2d.cxx
	svx/Package_inc.mk
	svx/inc/svx/sdr/overlay/overlayanimatedbitmapex.hxx
	svx/inc/svx/sdr/overlay/overlayobject.hxx
	svx/inc/svx/sdr/overlay/overlaypolypolygon.hxx
	svx/inc/svx/sdr/overlay/overlayrectangle.hxx
	svx/inc/svx/sdr/overlay/overlaytools.hxx
	svx/inc/svx/sdr/primitive2d/svx_primitivetypes2d.hxx
	svx/inc/svx/svdview.hxx
	svx/source/engine3d/view3d.cxx
	svx/source/sdr/overlay/overlayanimatedbitmapex.cxx
	svx/source/sdr/overlay/overlayhatchrect.cxx
	svx/source/sdr/overlay/overlaypolypolygon.cxx
	svx/source/sdr/overlay/overlaytools.cxx
	svx/source/svdraw/svdcrtv.cxx
	svx/source/svdraw/svdedxv.cxx
	svx/source/svdraw/svdhdl.cxx
	svx/source/svdraw/svdobj.cxx
	svx/source/svdraw/svdview.cxx
	sw/source/ui/dochdl/swdtflvr.cxx

Unname unused arguments to prevent WaE issues.

(cherry picked from commit 0735a61e631b8d4bb3d4e889bee436fb9e7c5734)

Change-Id: I3b1cf4754063985dc1b4adac44b33e52e200607f
e4288936cadd1f6e06bdf79611536d7114236b56
2013-06-16 20:01:56 +01:00

447 lines
17 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_DRAWINGLAYER_PRIMITIVE2D_POLYPOLYGONPRIMITIVE2D_HXX
#define INCLUDED_DRAWINGLAYER_PRIMITIVE2D_POLYPOLYGONPRIMITIVE2D_HXX
#include <drawinglayer/drawinglayerdllapi.h>
#include <drawinglayer/primitive2d/baseprimitive2d.hxx>
#include <drawinglayer/attribute/fillgraphicattribute.hxx>
#include <basegfx/polygon/b2dpolypolygon.hxx>
#include <drawinglayer/attribute/lineattribute.hxx>
#include <drawinglayer/attribute/strokeattribute.hxx>
#include <drawinglayer/attribute/linestartendattribute.hxx>
#include <drawinglayer/attribute/fillgradientattribute.hxx>
#include <drawinglayer/attribute/fillhatchattribute.hxx>
#include <drawinglayer/primitive2d/primitivetools2d.hxx>
#include <basegfx/color/bcolor.hxx>
//////////////////////////////////////////////////////////////////////////////
// PolyPolygonHairlinePrimitive2D class
namespace drawinglayer
{
namespace primitive2d
{
/** PolyPolygonHairlinePrimitive2D class
This primitive defines a multi-PolygonHairlinePrimitive2D and is
just for convenience. The definition is not different from the single
defined PolygonHairlinePrimitive2Ds.
*/
class DRAWINGLAYER_DLLPUBLIC PolyPolygonHairlinePrimitive2D : public BufferedDecompositionPrimitive2D
{
private:
/// the hairline geometry
basegfx::B2DPolyPolygon maPolyPolygon;
/// the hairline color
basegfx::BColor maBColor;
protected:
/// local decomposition.
virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const;
public:
/// constructor
PolyPolygonHairlinePrimitive2D(const basegfx::B2DPolyPolygon& rPolyPolygon, const basegfx::BColor& rBColor);
/// data read access
const basegfx::B2DPolyPolygon& getB2DPolyPolygon() const { return maPolyPolygon; }
const basegfx::BColor& getBColor() const { return maBColor; }
/// compare operator
virtual bool operator==(const BasePrimitive2D& rPrimitive) const;
/// get range
virtual basegfx::B2DRange getB2DRange(const geometry::ViewInformation2D& rViewInformation) const;
/// provide unique ID
DeclPrimitive2DIDBlock()
};
} // end of namespace primitive2d
} // end of namespace drawinglayer
//////////////////////////////////////////////////////////////////////////////
// PolyPolygonMarkerPrimitive2D class
namespace drawinglayer
{
namespace primitive2d
{
/** PolyPolygonMarkerPrimitive2D class
This primitive defines a multi-PolygonMarkerPrimitive2D and is
just for convenience. The definition is not different from the single
defined PolygonMarkerPrimitive2Ds.
*/
class DRAWINGLAYER_DLLPUBLIC PolyPolygonMarkerPrimitive2D : public BufferedDecompositionPrimitive2D
{
private:
/// the marker hairline geometry
basegfx::B2DPolyPolygon maPolyPolygon;
/// the two colors
basegfx::BColor maRGBColorA;
basegfx::BColor maRGBColorB;
/// the dash distance in 'pixels'
double mfDiscreteDashLength;
protected:
/// local decomposition.
virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const;
public:
/// constructor
PolyPolygonMarkerPrimitive2D(
const basegfx::B2DPolyPolygon& rPolyPolygon,
const basegfx::BColor& rRGBColorA,
const basegfx::BColor& rRGBColorB,
double fDiscreteDashLength);
// data read access
const basegfx::B2DPolyPolygon& getB2DPolyPolygon() const { return maPolyPolygon; }
const basegfx::BColor& getRGBColorA() const { return maRGBColorA; }
const basegfx::BColor& getRGBColorB() const { return maRGBColorB; }
double getDiscreteDashLength() const { return mfDiscreteDashLength; }
/// compare operator
virtual bool operator==(const BasePrimitive2D& rPrimitive) const;
/// get range
virtual basegfx::B2DRange getB2DRange(const geometry::ViewInformation2D& rViewInformation) const;
/// provide unique ID
DeclPrimitive2DIDBlock()
};
} // end of namespace primitive2d
} // end of namespace drawinglayer
//////////////////////////////////////////////////////////////////////////////
// PolyPolygonStrokePrimitive2D class
namespace drawinglayer
{
namespace primitive2d
{
/** PolyPolygonStrokePrimitive2D class
This primitive defines a multi-PolygonStrokePrimitive2D and is
just for convenience. The definition is not different from the single
defined PolygonStrokePrimitive2Ds.
*/
class DRAWINGLAYER_DLLPUBLIC PolyPolygonStrokePrimitive2D : public BufferedDecompositionPrimitive2D
{
private:
/// the line geometry
basegfx::B2DPolyPolygon maPolyPolygon;
/// the line attributes like width, join and color
attribute::LineAttribute maLineAttribute;
/// the line stroking (if used)
attribute::StrokeAttribute maStrokeAttribute;
protected:
/// local decomposition.
virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const;
public:
/// constructor
PolyPolygonStrokePrimitive2D(
const basegfx::B2DPolyPolygon& rPolyPolygon,
const attribute::LineAttribute& rLineAttribute,
const attribute::StrokeAttribute& rStrokeAttribute);
PolyPolygonStrokePrimitive2D(
const basegfx::B2DPolyPolygon& rPolyPolygon,
const attribute::LineAttribute& rLineAttribute);
/// data read access
const basegfx::B2DPolyPolygon& getB2DPolyPolygon() const { return maPolyPolygon; }
const attribute::LineAttribute& getLineAttribute() const { return maLineAttribute; }
const attribute::StrokeAttribute& getStrokeAttribute() const { return maStrokeAttribute; }
/// compare operator
virtual bool operator==(const BasePrimitive2D& rPrimitive) const;
/// get range
virtual basegfx::B2DRange getB2DRange(const geometry::ViewInformation2D& rViewInformation) const;
/// provide unique ID
DeclPrimitive2DIDBlock()
};
} // end of namespace primitive2d
} // end of namespace drawinglayer
//////////////////////////////////////////////////////////////////////////////
// PolyPolygonColorPrimitive2D class
namespace drawinglayer
{
namespace primitive2d
{
/** PolyPolygonColorPrimitive2D class
This primitive defines a PolyPolygon filled with a single color.
This is one of the non-decomposable primitives, so a renderer
should proccess it.
*/
class DRAWINGLAYER_DLLPUBLIC PolyPolygonColorPrimitive2D : public BasePrimitive2D
{
private:
/// the PolyPolygon geometry
basegfx::B2DPolyPolygon maPolyPolygon;
/// the polygon fill color
basegfx::BColor maBColor;
public:
/// constructor
PolyPolygonColorPrimitive2D(
const basegfx::B2DPolyPolygon& rPolyPolygon,
const basegfx::BColor& rBColor);
/// data read access
const basegfx::B2DPolyPolygon& getB2DPolyPolygon() const { return maPolyPolygon; }
const basegfx::BColor& getBColor() const { return maBColor; }
/// compare operator
virtual bool operator==(const BasePrimitive2D& rPrimitive) const;
/// get range
virtual basegfx::B2DRange getB2DRange(const geometry::ViewInformation2D& rViewInformation) const;
/// provide unique ID
DeclPrimitive2DIDBlock()
};
} // end of namespace primitive2d
} // end of namespace drawinglayer
//////////////////////////////////////////////////////////////////////////////
// PolyPolygonGradientPrimitive2D class
namespace drawinglayer
{
namespace primitive2d
{
/** PolyPolygonColorPrimitive2D class
This primitive defines a PolyPolygon filled with a gradient. The
decomosition will create a MaskPrimitive2D containing a
FillGradientPrimitive2D.
*/
class DRAWINGLAYER_DLLPUBLIC PolyPolygonGradientPrimitive2D : public BufferedDecompositionPrimitive2D
{
private:
/// the PolyPolygon geometry
basegfx::B2DPolyPolygon maPolyPolygon;
/// the gradient definition
attribute::FillGradientAttribute maFillGradient;
protected:
/// local decomposition.
virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const;
public:
/// constructor
PolyPolygonGradientPrimitive2D(
const basegfx::B2DPolyPolygon& rPolyPolygon,
const attribute::FillGradientAttribute& rFillGradient);
/// data read access
const basegfx::B2DPolyPolygon& getB2DPolyPolygon() const { return maPolyPolygon; }
const attribute::FillGradientAttribute& getFillGradient() const { return maFillGradient; }
/// compare operator
virtual bool operator==(const BasePrimitive2D& rPrimitive) const;
/// provide unique ID
DeclPrimitive2DIDBlock()
};
} // end of namespace primitive2d
} // end of namespace drawinglayer
//////////////////////////////////////////////////////////////////////////////
// PolyPolygonHatchPrimitive2D class
namespace drawinglayer
{
namespace primitive2d
{
/** PolyPolygonHatchPrimitive2D class
This primitive defines a PolyPolygon filled with a hatch. The
decomosition will create a MaskPrimitive2D containing a
FillHatchPrimitive2D.
*/
class DRAWINGLAYER_DLLPUBLIC PolyPolygonHatchPrimitive2D : public BufferedDecompositionPrimitive2D
{
private:
/// the PolyPolygon geometry
basegfx::B2DPolyPolygon maPolyPolygon;
/// the hatch background color (if used)
basegfx::BColor maBackgroundColor;
/// the hatch definition
attribute::FillHatchAttribute maFillHatch;
protected:
/// local decomposition.
virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const;
public:
/// constructor
PolyPolygonHatchPrimitive2D(
const basegfx::B2DPolyPolygon& rPolyPolygon,
const basegfx::BColor& rBackgroundColor,
const attribute::FillHatchAttribute& rFillHatch);
/// data read access
const basegfx::B2DPolyPolygon& getB2DPolyPolygon() const { return maPolyPolygon; }
const basegfx::BColor& getBackgroundColor() const { return maBackgroundColor; }
const attribute::FillHatchAttribute& getFillHatch() const { return maFillHatch; }
/// compare operator
virtual bool operator==(const BasePrimitive2D& rPrimitive) const;
/// provide unique ID
DeclPrimitive2DIDBlock()
};
} // end of namespace primitive2d
} // end of namespace drawinglayer
//////////////////////////////////////////////////////////////////////////////
// PolyPolygonGraphicPrimitive2D class
namespace drawinglayer
{
namespace primitive2d
{
/** PolyPolygonGraphicPrimitive2D class
This primitive defines a PolyPolygon filled with bitmap data
(including transparence). The decomosition will create a MaskPrimitive2D
containing a FillGraphicPrimitive2D.
*/
class DRAWINGLAYER_DLLPUBLIC PolyPolygonGraphicPrimitive2D : public BufferedDecompositionPrimitive2D
{
private:
/// the PolyPolygon geometry
basegfx::B2DPolyPolygon maPolyPolygon;
/// the bitmap fill definition (may include tiling)
attribute::FillGraphicAttribute maFillGraphic;
protected:
/// local decomposition.
virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const;
public:
/// constructor
PolyPolygonGraphicPrimitive2D(
const basegfx::B2DPolyPolygon& rPolyPolygon,
const attribute::FillGraphicAttribute& rFillGraphic);
/// data read access
const basegfx::B2DPolyPolygon& getB2DPolyPolygon() const { return maPolyPolygon; }
const attribute::FillGraphicAttribute& getFillGraphic() const { return maFillGraphic; }
/// compare operator
virtual bool operator==(const BasePrimitive2D& rPrimitive) const;
/// provide unique ID
DeclPrimitive2DIDBlock()
};
} // end of namespace primitive2d
} // end of namespace drawinglayer
//////////////////////////////////////////////////////////////////////////////
// PolyPolygonSelectionPrimitive2D class
namespace drawinglayer
{
namespace primitive2d
{
/** PolyPolygonSelectionPrimitive2D class
This primitive defines a PolyPolygon which gets filled with a defined color
and a defined transparence, but also gets extended ('grown') by the given
discrete size (thus being a view-dependent primitive)
*/
class DRAWINGLAYER_DLLPUBLIC PolyPolygonSelectionPrimitive2D : public DiscreteMetricDependentPrimitive2D
{
private:
/// the PolyPolygon geometry
basegfx::B2DPolyPolygon maPolyPolygon;
/// the color
basegfx::BColor maColor;
/// the transparence [0.0 .. 1.0]
double mfTransparence;
/// the discrete grow size ('pixels'), only posivive values allowed
double mfDiscreteGrow;
/// bitfield
/// draw polygons filled when fill is set
bool mbFill : 1;
protected:
/// local decomposition.
virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const;
public:
/// constructor
PolyPolygonSelectionPrimitive2D(
const basegfx::B2DPolyPolygon& rPolyPolygon,
const basegfx::BColor& rColor,
double fTransparence,
double fDiscreteGrow,
bool bFill);
/// data read access
const basegfx::B2DPolyPolygon& getB2DPolyPolygon() const { return maPolyPolygon; }
const basegfx::BColor& getColor() const { return maColor; }
double getTransparence() const { return mfTransparence; }
double getDiscreteGrow() const { return mfDiscreteGrow; }
bool getFill() const { return mbFill; }
/// compare operator
virtual bool operator==(const BasePrimitive2D& rPrimitive) const;
/// get range
virtual basegfx::B2DRange getB2DRange(const geometry::ViewInformation2D& rViewInformation) const;
/// provide unique ID
DeclPrimitive2DIDBlock()
};
} // end of namespace primitive2d
} // end of namespace drawinglayer
//////////////////////////////////////////////////////////////////////////////
#endif //INCLUDED_DRAWINGLAYER_PRIMITIVE2D_POLYPOLYGONPRIMITIVE2D_HXX
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */