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

#define INCLUDED_SVX_INC_SDR_OVERLAY_OVERLAYTOOLS_HXX

#include <basegfx/color/bcolor.hxx>

#include <drawinglayer/primitive2d/primitivetools2d.hxx>

#include <vcl/bitmap.hxx>

#include <basegfx/vector/b2dsize.hxx>

namespace drawinglayer::primitive2d {

class OverlayStaticRectanglePrimitive final : public DiscreteMetricDependentPrimitive2D

{

private:

    basegfx::B2DPoint maPosition;

    basegfx::B2DSize maSize;

    // the graphic definition

    basegfx::BColor maStrokeColor;

    basegfx::BColor maFillColor;

    double mfTransparence;

    // the rotation of the primitive itself

    double mfRotation;

    virtual Primitive2DReference create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;

public:

    OverlayStaticRectanglePrimitive(

        const basegfx::B2DPoint& rPosition,

        const basegfx::B2DSize& rSize,

        const basegfx::BColor& rStrokeColor,

        const basegfx::BColor& rFillColor,

        double fTransparence,

        double fRotation);

    // compare operator

    virtual bool operator==( const BasePrimitive2D& rPrimitive ) const override;

    virtual sal_uInt32 getPrimitive2DID() const override;

};

} // end of namespace drawinglayer::primitive2d

// Overlay helper class which holds a BotmapEx which is to be visualized

// at the given logic position with the Bitmap's pixel size, unscaled and

// unrotated (like a marker). The discrete pixel on the bitmap associated

// with the target position is given in discrete X,Y coordinates

namespace drawinglayer::primitive2d

    {

        class OverlayBitmapPrimitive final : public DiscreteMetricDependentPrimitive2D

        {

        private:

            // The Bitmap to use, PixelSize is used

            Bitmap                                  maBitmap;

            // The logic position

            basegfx::B2DPoint                       maBasePosition;

            // The pixel inside the Bitmap which is associated with

            // the target position (offset in the bitmap)

            sal_uInt16                              mnCenterX;

            sal_uInt16                              mnCenterY;

            // evtl. rotation and shear around center

            double                                  mfShearX;

            double                                  mfRotation;

            virtual Primitive2DReference create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;

        public:

            OverlayBitmapPrimitive(

                const Bitmap& rBitmap,

                const basegfx::B2DPoint& rBasePosition,

                sal_uInt16 nCenterX,

                sal_uInt16 nCenterY,

                double fShearX,

                double fRotation);

            // data access

            const Bitmap& getBitmap() const { return maBitmap; }

            const basegfx::B2DPoint& getBasePosition() const { return maBasePosition; }

            sal_uInt16 getCenterX() const { return mnCenterX; }

            sal_uInt16 getCenterY() const { return mnCenterY; }

            double getShearX() const { return mfShearX; }

            double getRotation() const { return mfRotation; }

            // compare operator

            virtual bool operator==( const BasePrimitive2D& rPrimitive ) const override;

            virtual sal_uInt32 getPrimitive2DID() const override;

        };

} // end of namespace drawinglayer::primitive2d

// Overlay helper class for a crosshair

namespace drawinglayer::primitive2d

    {

        class OverlayCrosshairPrimitive final : public ViewportDependentPrimitive2D

        {

        private:

            // The logic position

            basegfx::B2DPoint                       maBasePosition;

            // The stripe colors and length

            basegfx::BColor                          maRGBColorA;

            basegfx::BColor                          maRGBColorB;

            double                                   mfDiscreteDashLength;

            virtual Primitive2DReference create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;

        public:

            OverlayCrosshairPrimitive(

                const basegfx::B2DPoint& rBasePosition,

                const basegfx::BColor& rRGBColorA,

                const basegfx::BColor& rRGBColorB,

                double fDiscreteDashLength);

            // data access

            const basegfx::B2DPoint& getBasePosition() const { return maBasePosition; }

            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 override;

            virtual sal_uInt32 getPrimitive2DID() const override;

        };

} // end of namespace drawinglayer::primitive2d

// Overlay helper class for a hatch rectangle as used e.g. for text object

// selection highlighting

namespace drawinglayer::primitive2d

    {

        class OverlayRectanglePrimitive final : public DiscreteMetricDependentPrimitive2D

        {

        private:

            // the logic rectangle definition

            basegfx::B2DRange               maObjectRange;

            // the graphic definition

            basegfx::BColor                 maColor;

            double                          mfTransparence;

            // the discrete grow and shrink of the box

            double                          mfDiscreteGrow;

            double                          mfDiscreteShrink;

            // the rotation of the primitive itself

            double                          mfRotation;

            virtual Primitive2DReference create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;

        public:

            OverlayRectanglePrimitive(

                const basegfx::B2DRange& rObjectRange,

                const basegfx::BColor& rColor,

                double fTransparence,

                double fDiscreteGrow,

                double fDiscreteShrink,

                double fRotation);

            // data access

            const basegfx::B2DRange& getObjectRange() const { return maObjectRange; }

            const basegfx::BColor& getColor() const { return maColor; }

            double getTransparence() const { return mfTransparence; }

            double getDiscreteGrow() const { return mfDiscreteGrow; }

            double getDiscreteShrink() const { return mfDiscreteShrink; }

            double getRotation() const { return mfRotation; }

            // compare operator

            virtual bool operator==( const BasePrimitive2D& rPrimitive ) const override;

            virtual sal_uInt32 getPrimitive2DID() const override;

        };

} // end of namespace drawinglayer::primitive2d

// Overlay helper class for a striped helpline

namespace drawinglayer::primitive2d

    {

        enum HelplineStyle

        {

            HELPLINESTYLE_POINT,

            HELPLINESTYLE_VERTICAL,

            HELPLINESTYLE_HORIZONTAL

        };

        class OverlayHelplineStripedPrimitive final : public ViewportDependentPrimitive2D

        {

        private:

            // The logic position

            basegfx::B2DPoint                       maBasePosition;

            // the style

            HelplineStyle                           meStyle;

            // The stripe colors and length

            basegfx::BColor                         maRGBColorA;

            basegfx::BColor                         maRGBColorB;

            double                                  mfDiscreteDashLength;

            virtual Primitive2DReference create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;

        public:

            OverlayHelplineStripedPrimitive(

                const basegfx::B2DPoint& rBasePosition,

                HelplineStyle eStyle,

                const basegfx::BColor& rRGBColorA,

                const basegfx::BColor& rRGBColorB,

                double fDiscreteDashLength);

            // data access

            const basegfx::B2DPoint& getBasePosition() const { return maBasePosition; }

            HelplineStyle getStyle() const { return meStyle; }

            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 override;

            virtual sal_uInt32 getPrimitive2DID() const override;

        };

} // end of namespace drawinglayer::primitive2d

// Overlay helper class for rolling rectangle helplines. This primitive is

// only for the extended lines to the ends of the view

namespace drawinglayer::primitive2d

    {

        class OverlayRollingRectanglePrimitive final : public ViewportDependentPrimitive2D

        {

        private:

            // The logic range

            basegfx::B2DRange                       maRollingRectangle;

            // The stripe colors and length

            basegfx::BColor                         maRGBColorA;

            basegfx::BColor                         maRGBColorB;

            double                                  mfDiscreteDashLength;

            virtual Primitive2DReference create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;

        public:

            OverlayRollingRectanglePrimitive(

                const basegfx::B2DRange& aRollingRectangle,

                const basegfx::BColor& rRGBColorA,

                const basegfx::BColor& rRGBColorB,

                double fDiscreteDashLength);

            // data access

            const basegfx::B2DRange& getRollingRectangle() const { return maRollingRectangle; }

            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 override;

            virtual sal_uInt32 getPrimitive2DID() const override;

        };

} // end of namespace drawinglayer::primitive2d

#endif // INCLUDED_SVX_INC_SDR_OVERLAY_OVERLAYTOOLS_HXX

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */