xref: /aoo41x/main/drawinglayer/source/primitive2d/gridprimitive2d.cxx (revision 2a27d9ca)

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