xref: /trunk/main/drawinglayer/source/primitive2d/gridprimitive2d.cxx (revision cf6516809c57e1bb0a940545cca99cdad54d4ce2)

/**************************************************************
 *
 * 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
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_drawinglayer.hxx"

#include <drawinglayer/primitive2d/gridprimitive2d.hxx>
#include <basegfx/tools/canvastools.hxx>
#include <drawinglayer/primitive2d/pointarrayprimitive2d.hxx>
#include <drawinglayer/primitive2d/markerarrayprimitive2d.hxx>
#include <drawinglayer/geometry/viewinformation2d.hxx>
#include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx>
#include <basegfx/matrix/b2dhommatrixtools.hxx>

//////////////////////////////////////////////////////////////////////////////

using namespace com::sun::star;

//////////////////////////////////////////////////////////////////////////////

namespace drawinglayer
{
    namespace primitive2d
    {
        Primitive2DSequence GridPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
        {
            Primitive2DSequence aRetval;

            if(!rViewInformation.getViewport().isEmpty() && getWidth() > 0.0 && getHeight() > 0.0)
            {
                // decompose grid matrix to get logic size
                basegfx::B2DVector aScale, aTranslate;
                double fRotate, fShearX;
                getTransform().decompose(aScale, aTranslate, fRotate, fShearX);

                // create grid matrix which transforms from scaled logic to view
                basegfx::B2DHomMatrix aRST(basegfx::tools::createShearXRotateTranslateB2DHomMatrix(
                    fShearX, fRotate, aTranslate.getX(), aTranslate.getY()));
                aRST *= rViewInformation.getObjectToViewTransformation();

                // get step widths
                double fStepX(getWidth());
                double fStepY(getHeight());
                const double fMinimalStep(10.0);

                // guarantee a step width of 10.0
                if(basegfx::fTools::less(fStepX, fMinimalStep))
                {
                    fStepX = fMinimalStep;
                }

                if(basegfx::fTools::less(fStepY, fMinimalStep))
                {
                    fStepY = fMinimalStep;
                }

                // get relative distances in view coordinates
                double fViewStepX((rViewInformation.getObjectToViewTransformation() * basegfx::B2DVector(fStepX, 0.0)).getLength());
                double fViewStepY((rViewInformation.getObjectToViewTransformation() * basegfx::B2DVector(0.0, fStepY)).getLength());
                double fSmallStepX(1.0), fViewSmallStepX(1.0), fSmallStepY(1.0), fViewSmallStepY(1.0);
                sal_uInt32 nSmallStepsX(0L), nSmallStepsY(0L);

                // setup subdivisions
                if(getSubdivisionsX())
                {
                    fSmallStepX = fStepX / getSubdivisionsX();
                    fViewSmallStepX = fViewStepX / getSubdivisionsX();
                }

                if(getSubdivisionsY())
                {
                    fSmallStepY = fStepY / getSubdivisionsY();
                    fViewSmallStepY = fViewStepY / getSubdivisionsY();
                }

                // correct step width
                while(fViewStepX < getSmallestViewDistance())
                {
                    fViewStepX *= 2.0;
                    fStepX *= 2.0;
                }

                while(fViewStepY < getSmallestViewDistance())
                {
                    fViewStepY *= 2.0;
                    fStepY *= 2.0;
                }

                // correct small step width
                if(getSubdivisionsX())
                {
                    while(fViewSmallStepX < getSmallestSubdivisionViewDistance())
                    {
                        fViewSmallStepX *= 2.0;
                        fSmallStepX *= 2.0;
                    }

                    nSmallStepsX = (sal_uInt32)(fStepX / fSmallStepX);
                }

                if(getSubdivisionsY())
                {
                    while(fViewSmallStepY < getSmallestSubdivisionViewDistance())
                    {
                        fViewSmallStepY *= 2.0;
                        fSmallStepY *= 2.0;
                    }

                    nSmallStepsY = (sal_uInt32)(fStepY / fSmallStepY);
                }

                // calculate extended viewport in which grid points may lie at all
                basegfx::B2DRange aExtendedViewport;

                if(rViewInformation.getDiscreteViewport().isEmpty())
                {
                    // not set, use logic size to travel over all potentioal grid points
                    aExtendedViewport = basegfx::B2DRange(0.0, 0.0, aScale.getX(), aScale.getY());
                }
                else
                {
                    // transform unit range to discrete view
                    aExtendedViewport = basegfx::B2DRange(0.0, 0.0, 1.0, 1.0);
                    basegfx::B2DHomMatrix aTrans(rViewInformation.getObjectToViewTransformation() * getTransform());
                    aExtendedViewport.transform(aTrans);

                    // intersect with visible part
                    aExtendedViewport.intersect(rViewInformation.getDiscreteViewport());

                    if(!aExtendedViewport.isEmpty())
                    {
                        // convert back and apply scale
                        aTrans.invert();
                        aTrans.scale(aScale.getX(), aScale.getY());
                        aExtendedViewport.transform(aTrans);

                        // crop start/end in X/Y to multiples of logical step width
                        const double fHalfCrossSize((rViewInformation.getInverseObjectToViewTransformation() * basegfx::B2DVector(3.0, 0.0)).getLength());
                        const double fMinX(floor((aExtendedViewport.getMinX() - fHalfCrossSize) / fStepX) * fStepX);
                        const double fMaxX(ceil((aExtendedViewport.getMaxX() + fHalfCrossSize) / fStepX) * fStepX);
                        const double fMinY(floor((aExtendedViewport.getMinY() - fHalfCrossSize) / fStepY) * fStepY);
                        const double fMaxY(ceil((aExtendedViewport.getMaxY() + fHalfCrossSize) / fStepY) * fStepY);

                        // put to aExtendedViewport and crop on object logic size
                        aExtendedViewport = basegfx::B2DRange(
                            std::max(fMinX, 0.0),
                            std::max(fMinY, 0.0),
                            std::min(fMaxX, aScale.getX()),
                            std::min(fMaxY, aScale.getY()));
                    }
                }

                if(!aExtendedViewport.isEmpty())
                {
                    // prepare point vectors for point and cross markers
                    std::vector< basegfx::B2DPoint > aPositionsPoint;
                    std::vector< basegfx::B2DPoint > aPositionsCross;

                    for(double fX(aExtendedViewport.getMinX()); fX < aExtendedViewport.getMaxX(); fX += fStepX)
                    {
                        const bool bXZero(basegfx::fTools::equalZero(fX));

                        for(double fY(aExtendedViewport.getMinY()); fY < aExtendedViewport.getMaxY(); fY += fStepY)
                        {
                            const bool bYZero(basegfx::fTools::equalZero(fY));

                            if(!bXZero && !bYZero)
                            {
                                // get discrete position and test against 3x3 area surrounding it
                                // since it's a cross
                                const double fHalfCrossSize(3.0 * 0.5);
                                const basegfx::B2DPoint aViewPos(aRST * basegfx::B2DPoint(fX, fY));
                                const basegfx::B2DRange aDiscreteRangeCross(
                                    aViewPos.getX() - fHalfCrossSize, aViewPos.getY() - fHalfCrossSize,
                                    aViewPos.getX() + fHalfCrossSize, aViewPos.getY() + fHalfCrossSize);

                                if(rViewInformation.getDiscreteViewport().overlaps(aDiscreteRangeCross))
                                {
                                    const basegfx::B2DPoint aLogicPos(rViewInformation.getInverseObjectToViewTransformation() * aViewPos);
                                    aPositionsCross.push_back(aLogicPos);
                                }
                            }

                            if(getSubdivisionsX() && !bYZero)
                            {
                                double fF(fX + fSmallStepX);

                                for(sal_uInt32 a(1); a < nSmallStepsX && fF < aExtendedViewport.getMaxX(); a++, fF += fSmallStepX)
                                {
                                    const basegfx::B2DPoint aViewPos(aRST * basegfx::B2DPoint(fF, fY));

                                    if(rViewInformation.getDiscreteViewport().isInside(aViewPos))
                                    {
                                        const basegfx::B2DPoint aLogicPos(rViewInformation.getInverseObjectToViewTransformation() * aViewPos);
                                        aPositionsPoint.push_back(aLogicPos);
                                    }
                                }
                            }

                            if(getSubdivisionsY() && !bXZero)
                            {
                                double fF(fY + fSmallStepY);

                                for(sal_uInt32 a(1); a < nSmallStepsY && fF < aExtendedViewport.getMaxY(); a++, fF += fSmallStepY)
                                {
                                    const basegfx::B2DPoint aViewPos(aRST * basegfx::B2DPoint(fX, fF));

                                    if(rViewInformation.getDiscreteViewport().isInside(aViewPos))
                                    {
                                        const basegfx::B2DPoint aLogicPos(rViewInformation.getInverseObjectToViewTransformation() * aViewPos);
                                        aPositionsPoint.push_back(aLogicPos);
                                    }
                                }
                            }
                        }
                    }

                    // prepare return value
                    const sal_uInt32 nCountPoint(aPositionsPoint.size());
                    const sal_uInt32 nCountCross(aPositionsCross.size());
                    const sal_uInt32 nRetvalCount((nCountPoint ? 1 : 0) + (nCountCross ? 1 : 0));
                    sal_uInt32 nInsertCounter(0);

                    aRetval.realloc(nRetvalCount);

                    // add PointArrayPrimitive2D if point markers were added
                    if(nCountPoint)
                    {
                        aRetval[nInsertCounter++] = Primitive2DReference(new PointArrayPrimitive2D(aPositionsPoint, getBColor()));
                    }

                    // add MarkerArrayPrimitive2D if cross markers were added
                    if(nCountCross)
                    {
                        if(!getSubdivisionsX() && !getSubdivisionsY())
                        {
                            // no subdivisions, so fall back to points at grid positions, no need to
                            // visualize a difference between divisions and sub-divisions
                            aRetval[nInsertCounter++] = Primitive2DReference(new PointArrayPrimitive2D(aPositionsCross, getBColor()));
                        }
                        else
                        {
                            aRetval[nInsertCounter++] = Primitive2DReference(new MarkerArrayPrimitive2D(aPositionsCross, getCrossMarker()));
                        }
                    }
                }
            }

            return aRetval;
        }

        GridPrimitive2D::GridPrimitive2D(
            const basegfx::B2DHomMatrix& rTransform,
            double fWidth,
            double fHeight,
            double fSmallestViewDistance,
            double fSmallestSubdivisionViewDistance,
            sal_uInt32 nSubdivisionsX,
            sal_uInt32 nSubdivisionsY,
            const basegfx::BColor& rBColor,
            const BitmapEx& rCrossMarker)
        :   BufferedDecompositionPrimitive2D(),
            maTransform(rTransform),
            mfWidth(fWidth),
            mfHeight(fHeight),
            mfSmallestViewDistance(fSmallestViewDistance),
            mfSmallestSubdivisionViewDistance(fSmallestSubdivisionViewDistance),
            mnSubdivisionsX(nSubdivisionsX),
            mnSubdivisionsY(nSubdivisionsY),
            maBColor(rBColor),
            maCrossMarker(rCrossMarker),
            maLastObjectToViewTransformation(),
            maLastViewport()
        {
        }

        bool GridPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
        {
            if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
            {
                const GridPrimitive2D& rCompare = (GridPrimitive2D&)rPrimitive;

                return (getTransform() == rCompare.getTransform()
                    && getWidth() == rCompare.getWidth()
                    && getHeight() == rCompare.getHeight()
                    && getSmallestViewDistance() == rCompare.getSmallestViewDistance()
                    && getSmallestSubdivisionViewDistance() == rCompare.getSmallestSubdivisionViewDistance()
                    && getSubdivisionsX() == rCompare.getSubdivisionsX()
                    && getSubdivisionsY() == rCompare.getSubdivisionsY()
                    && getBColor() == rCompare.getBColor()
                    && getCrossMarker() == rCompare.getCrossMarker());
            }

            return false;
        }

        basegfx::B2DRange GridPrimitive2D::getB2DRange(const geometry::ViewInformation2D& rViewInformation) const
        {
            // get object's range
            basegfx::B2DRange aUnitRange(0.0, 0.0, 1.0, 1.0);
            aUnitRange.transform(getTransform());

            // intersect with visible part
            aUnitRange.intersect(rViewInformation.getViewport());

            return aUnitRange;
        }

        Primitive2DSequence GridPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
        {
            ::osl::MutexGuard aGuard( m_aMutex );

            if(getBuffered2DDecomposition().hasElements())
            {
                if(maLastViewport != rViewInformation.getViewport() || maLastObjectToViewTransformation != rViewInformation.getObjectToViewTransformation())
                {
                    // conditions of last local decomposition have changed, delete
                    const_cast< GridPrimitive2D* >(this)->setBuffered2DDecomposition(Primitive2DSequence());
                }
            }

            if(!getBuffered2DDecomposition().hasElements())
            {
                // remember ViewRange and ViewTransformation
                const_cast< GridPrimitive2D* >(this)->maLastObjectToViewTransformation = rViewInformation.getObjectToViewTransformation();
                const_cast< GridPrimitive2D* >(this)->maLastViewport = rViewInformation.getViewport();
            }

            // use parent implementation
            return BufferedDecompositionPrimitive2D::get2DDecomposition(rViewInformation);
        }

        // provide unique ID
        ImplPrimitrive2DIDBlock(GridPrimitive2D, PRIMITIVE2D_ID_GRIDPRIMITIVE2D)

    } // end of namespace primitive2d
} // end of namespace drawinglayer

//////////////////////////////////////////////////////////////////////////////
// eof