xref: /aoo41x/main/svx/source/sdr/overlay/overlaymanager.cxx (revision a7185797)

/**************************************************************
 *
 * 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_svx.hxx"
#include <svx/sdr/overlay/overlaymanager.hxx>
#include <basegfx/point/b2dpoint.hxx>
#include <basegfx/range/b2drange.hxx>
#include <tools/gen.hxx>
#include <vcl/salbtype.hxx>
#include <vcl/outdev.hxx>
#include <vcl/window.hxx>
#include <svx/sdr/overlay/overlayobject.hxx>
#include <basegfx/matrix/b2dhommatrix.hxx>
#include <drawinglayer/processor2d/processor2dtools.hxx>

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

using namespace com::sun::star;

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

namespace sdr
{
	namespace overlay
	{
		void OverlayManager::ImpDrawMembers(const basegfx::B2DRange& rRange, OutputDevice& rDestinationDevice) const
		{
			const sal_uInt32 nSize(maOverlayObjects.size());

			if(nSize)
			{
				const sal_uInt16 nOriginalAA(rDestinationDevice.GetAntialiasing());
				const bool bIsAntiAliasing(getDrawinglayerOpt().IsAntiAliasing());

				// create processor
				drawinglayer::processor2d::BaseProcessor2D* pProcessor = drawinglayer::processor2d::createProcessor2DFromOutputDevice(
					rDestinationDevice,
					getCurrentViewInformation2D());

				if(pProcessor)
				{
					for(OverlayObjectVector::const_iterator aIter(maOverlayObjects.begin()); aIter != maOverlayObjects.end(); aIter++)
					{
						OSL_ENSURE(*aIter, "Corrupted OverlayObject List (!)");
						const OverlayObject& rCandidate = **aIter;

						if(rCandidate.isVisible())
						{
							const drawinglayer::primitive2d::Primitive2DSequence& rSequence = rCandidate.getOverlayObjectPrimitive2DSequence();

							if(rSequence.hasElements())
							{
								if(rRange.overlaps(rCandidate.getBaseRange()))
								{
									if(bIsAntiAliasing && rCandidate.allowsAntiAliase())
									{
										rDestinationDevice.SetAntialiasing(nOriginalAA | ANTIALIASING_ENABLE_B2DDRAW);
									}
									else
									{
										rDestinationDevice.SetAntialiasing(nOriginalAA & ~ANTIALIASING_ENABLE_B2DDRAW);
									}

									pProcessor->process(rSequence);
								}
							}
						}
					}

					delete pProcessor;
				}

				// restore AA settings
				rDestinationDevice.SetAntialiasing(nOriginalAA);
			}
		}

		void OverlayManager::ImpStripeDefinitionChanged()
		{
			const sal_uInt32 nSize(maOverlayObjects.size());

			if(nSize)
			{
				for(OverlayObjectVector::iterator aIter(maOverlayObjects.begin()); aIter != maOverlayObjects.end(); aIter++)
				{
					OSL_ENSURE(*aIter, "Corrupted OverlayObject List (!)");
					OverlayObject& rCandidate = **aIter;
					rCandidate.stripeDefinitionHasChanged();
				}
			}
		}

        double OverlayManager::getDiscreteOne() const
        {
			if(basegfx::fTools::equalZero(mfDiscreteOne))
            {
                const basegfx::B2DVector aDiscreteInLogic(getOutputDevice().GetInverseViewTransformation() * basegfx::B2DVector(1.0, 0.0));
                const_cast< OverlayManager* >(this)->mfDiscreteOne = aDiscreteInLogic.getLength();
            }

            return mfDiscreteOne;
        }

		OverlayManager::OverlayManager(OutputDevice& rOutputDevice)
		:	Scheduler(),
			rmOutputDevice(rOutputDevice),
			maOverlayObjects(),
			maStripeColorA(Color(COL_BLACK)),
			maStripeColorB(Color(COL_WHITE)),
			mnStripeLengthPixel(5),
			maDrawinglayerOpt(),
            maViewTransformation(),
			maViewInformation2D(),
            mfDiscreteOne(0.0)
		{
            // set Property 'ReducedDisplayQuality' to true to allow simpler interaction
            // visualisations
            static bool bUseReducedDisplayQualityForDrag(true);

            if(bUseReducedDisplayQualityForDrag)
            {
			    uno::Sequence< beans::PropertyValue > xProperties(1);
			    xProperties[0].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ReducedDisplayQuality"));
			    xProperties[0].Value <<= true;
                maViewInformation2D = drawinglayer::geometry::ViewInformation2D(xProperties);
            }
		}

		const drawinglayer::geometry::ViewInformation2D OverlayManager::getCurrentViewInformation2D() const
		{
            if(getOutputDevice().GetViewTransformation() != maViewTransformation)
            {
				basegfx::B2DRange aViewRange(maViewInformation2D.getViewport());

				if(OUTDEV_WINDOW == getOutputDevice().GetOutDevType())
				{
					const Size aOutputSizePixel(getOutputDevice().GetOutputSizePixel());

                    // only set when we *have* a output size, else let aViewRange
                    // stay on empty
                    if(aOutputSizePixel.Width() && aOutputSizePixel.Height())
                    {
                        aViewRange = basegfx::B2DRange(0.0, 0.0, aOutputSizePixel.getWidth(), aOutputSizePixel.getHeight());
                        aViewRange.transform(getOutputDevice().GetInverseViewTransformation());
                    }
				}

                OverlayManager* pThis = const_cast< OverlayManager* >(this);

				pThis->maViewTransformation = getOutputDevice().GetViewTransformation();
				pThis->maViewInformation2D = drawinglayer::geometry::ViewInformation2D(
					maViewInformation2D.getObjectTransformation(),
					maViewTransformation,
					aViewRange,
					maViewInformation2D.getVisualizedPage(),
					maViewInformation2D.getViewTime(),
					maViewInformation2D.getExtendedInformationSequence());
				pThis->mfDiscreteOne = 0.0;
            }

			return maViewInformation2D;
		}

		void OverlayManager::impApplyRemoveActions(OverlayObject& rTarget)
		{
			// handle evtl. animation
			if(rTarget.allowsAnimation())
			{
				// remove from event chain
				RemoveEvent(&rTarget);
			}

			// make invisible
			invalidateRange(rTarget.getBaseRange());

			// clear manager
			rTarget.mpOverlayManager = 0;
		}

		void OverlayManager::impApplyAddActions(OverlayObject& rTarget)
		{
			// set manager
			rTarget.mpOverlayManager = this;

			// make visible
			invalidateRange(rTarget.getBaseRange());

			// handle evtl. animation
			if(rTarget.allowsAnimation())
			{
				// Trigger at current time to get alive. This will do the
				// object-specific next time calculation and hand over adding
				// again to the scheduler to the animated object, too. This works for
				// a paused or non-paused animator.
				rTarget.Trigger(GetTime());
			}
		}

		OverlayManager::~OverlayManager()
		{
			// The OverlayManager is not the owner of the OverlayObjects
			// and thus will not delete them, but remove them. Profit here
			// from knowing that all will be removed
			const sal_uInt32 nSize(maOverlayObjects.size());

			if(nSize)
			{
				for(OverlayObjectVector::iterator aIter(maOverlayObjects.begin()); aIter != maOverlayObjects.end(); aIter++)
				{
					OSL_ENSURE(*aIter, "Corrupted OverlayObject List (!)");
					OverlayObject& rCandidate = **aIter;
					impApplyRemoveActions(rCandidate);
				}

				// erase vector
				maOverlayObjects.clear();
			}
		}

		void OverlayManager::completeRedraw(const Region& rRegion, OutputDevice* pPreRenderDevice) const
		{
			if(!rRegion.IsEmpty() && maOverlayObjects.size())
			{
				// check for changed MapModes. That may influence the
				// logical size of pixel based OverlayObjects (like BitmapHandles)
				//ImpCheckMapModeChange();

				// paint members
				const Rectangle aRegionBoundRect(rRegion.GetBoundRect());
				const basegfx::B2DRange aRegionRange(
					aRegionBoundRect.Left(), aRegionBoundRect.Top(),
					aRegionBoundRect.Right(), aRegionBoundRect.Bottom());

				OutputDevice& rTarget = (pPreRenderDevice) ? *pPreRenderDevice : getOutputDevice();
				ImpDrawMembers(aRegionRange, rTarget);
			}
		}

		void OverlayManager::flush()
		{
			// default has nothing to do
		}

		// #i68597# part of content gets copied, react on it
		void OverlayManager::copyArea(const Point& /*rDestPt*/, const Point& /*rSrcPt*/, const Size& /*rSrcSize*/)
		{
			// unbuffered versions do nothing here
		}

		void OverlayManager::restoreBackground(const Region& /*rRegion*/) const
		{
			// unbuffered versions do nothing here
		}

		void OverlayManager::add(OverlayObject& rOverlayObject)
		{
			OSL_ENSURE(0 == rOverlayObject.mpOverlayManager, "OverlayObject is added twice to an OverlayManager (!)");

			// add to the end of chain to preserve display order in paint
			maOverlayObjects.push_back(&rOverlayObject);

			// execute add actions
			impApplyAddActions(rOverlayObject);
		}

		void OverlayManager::remove(OverlayObject& rOverlayObject)
		{
			OSL_ENSURE(rOverlayObject.mpOverlayManager == this, "OverlayObject is removed from wrong OverlayManager (!)");

			// execute remove actions
			impApplyRemoveActions(rOverlayObject);

			// remove from vector
			const OverlayObjectVector::iterator aFindResult = ::std::find(maOverlayObjects.begin(), maOverlayObjects.end(), &rOverlayObject);
			const bool bFound(aFindResult != maOverlayObjects.end());
			OSL_ENSURE(bFound, "OverlayObject NOT found at OverlayManager (!)");

			if(bFound)
			{
				maOverlayObjects.erase(aFindResult);
			}
		}

		void OverlayManager::invalidateRange(const basegfx::B2DRange& rRange)
		{
			if(OUTDEV_WINDOW == getOutputDevice().GetOutDevType())
			{
				if(getDrawinglayerOpt().IsAntiAliasing())
				{
					// assume AA needs one pixel more and invalidate one pixel more
                    const double fDiscreteOne(getDiscreteOne());
					const Rectangle aInvalidateRectangle(
						(sal_Int32)floor(rRange.getMinX() - fDiscreteOne),
						(sal_Int32)floor(rRange.getMinY() - fDiscreteOne),
						(sal_Int32)ceil(rRange.getMaxX() + fDiscreteOne),
						(sal_Int32)ceil(rRange.getMaxY() + fDiscreteOne));

					// simply invalidate
					((Window&)getOutputDevice()).Invalidate(aInvalidateRectangle, INVALIDATE_NOERASE);
				}
				else
				{
					// #i77674# transform to rectangle. Use floor/ceil to get all covered
					// discrete pixels, see #i75163# and OverlayManagerBuffered::invalidateRange
					const Rectangle aInvalidateRectangle(
						(sal_Int32)floor(rRange.getMinX()), (sal_Int32)floor(rRange.getMinY()),
						(sal_Int32)ceil(rRange.getMaxX()), (sal_Int32)ceil(rRange.getMaxY()));

					// simply invalidate
					((Window&)getOutputDevice()).Invalidate(aInvalidateRectangle, INVALIDATE_NOERASE);
				}
			}
		}

		// stripe support ColA
		void OverlayManager::setStripeColorA(Color aNew)
		{
			if(aNew != maStripeColorA)
			{
				maStripeColorA = aNew;
				ImpStripeDefinitionChanged();
			}
		}

		// stripe support ColB
		void OverlayManager::setStripeColorB(Color aNew)
		{
			if(aNew != maStripeColorB)
			{
				maStripeColorB = aNew;
				ImpStripeDefinitionChanged();
			}
		}

		// stripe support StripeLengthPixel
		void OverlayManager::setStripeLengthPixel(sal_uInt32 nNew)
		{
			if(nNew != mnStripeLengthPixel)
			{
				mnStripeLengthPixel = nNew;
				ImpStripeDefinitionChanged();
			}
		}
	} // end of namespace overlay
} // end of namespace sdr

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