xref: /aoo4110/main/drawinglayer/source/primitive2d/controlprimitive2d.cxx (revision b1cdbd2c)

/**************************************************************
 *
 * 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/controlprimitive2d.hxx>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <comphelper/processfactory.hxx>
#include <com/sun/star/awt/XWindow2.hpp>
#include <drawinglayer/geometry/viewinformation2d.hxx>
#include <vcl/virdev.hxx>
#include <vcl/svapp.hxx>
#include <com/sun/star/awt/PosSize.hpp>
#include <vcl/bitmapex.hxx>
#include <drawinglayer/primitive2d/bitmapprimitive2d.hxx>
#include <tools/diagnose_ex.h>
#include <basegfx/polygon/b2dpolygontools.hxx>
#include <basegfx/polygon/b2dpolygon.hxx>
#include <drawinglayer/primitive2d/polygonprimitive2d.hxx>
#include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx>
#include <svtools/optionsdrawinglayer.hxx>
#include <toolkit/awt/vclxwindow.hxx>
#include <vcl/window.hxx>
#include <basegfx/matrix/b2dhommatrixtools.hxx>

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

using namespace com::sun::star;

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

namespace drawinglayer
{
	namespace primitive2d
	{
		void ControlPrimitive2D::createXControl()
		{
			if(!mxXControl.is() && getControlModel().is())
			{
				uno::Reference< beans::XPropertySet > xSet(getControlModel(), uno::UNO_QUERY);

				if(xSet.is())
				{
					uno::Any aValue(xSet->getPropertyValue(rtl::OUString::createFromAscii("DefaultControl")));
					rtl::OUString aUnoControlTypeName;

					if(aValue >>= aUnoControlTypeName)
					{
						if(aUnoControlTypeName.getLength())
						{
							uno::Reference< lang::XMultiServiceFactory > xFactory( comphelper::getProcessServiceFactory() );

							if(xFactory.is())
							{
								uno::Reference< awt::XControl > xXControl(xFactory->createInstance(aUnoControlTypeName), uno::UNO_QUERY);

								if(xXControl.is())
								{
									xXControl->setModel(getControlModel());

									// remember XControl
									mxXControl = xXControl;
								}
							}
						}
					}
				}
			}
		}

		Primitive2DReference ControlPrimitive2D::createBitmapDecomposition(const geometry::ViewInformation2D& rViewInformation) const
		{
			Primitive2DReference xRetval;
			const uno::Reference< awt::XControl >& rXControl(getXControl());

			if(rXControl.is())
			{
				uno::Reference< awt::XWindow > xControlWindow(rXControl, uno::UNO_QUERY);

				if(xControlWindow.is())
				{
					// get decomposition to get size
					basegfx::B2DVector aScale, aTranslate;
					double fRotate, fShearX;
					getTransform().decompose(aScale, aTranslate, fRotate, fShearX);

					// get absolute discrete size (no mirror or rotate here)
					aScale = basegfx::absolute(aScale);
					basegfx::B2DVector aDiscreteSize(rViewInformation.getObjectToViewTransformation() * aScale);

					// limit to a maximum square size, e.g. 300x150 pixels (45000)
                    const SvtOptionsDrawinglayer aDrawinglayerOpt;
					const double fDiscreteMax(aDrawinglayerOpt.GetQuadraticFormControlRenderLimit());
					const double fDiscreteQuadratic(aDiscreteSize.getX() * aDiscreteSize.getY());
                    const bool bScaleUsed(fDiscreteQuadratic > fDiscreteMax);
                    double fFactor(1.0);

					if(bScaleUsed)
					{
                        // get factor and adapt to scaled size
						fFactor = sqrt(fDiscreteMax / fDiscreteQuadratic);
						aDiscreteSize *= fFactor;
					}

					// go to integer
					const sal_Int32 nSizeX(basegfx::fround(aDiscreteSize.getX()));
					const sal_Int32 nSizeY(basegfx::fround(aDiscreteSize.getY()));

					if(nSizeX > 0 && nSizeY > 0)
					{
						// prepare VirtualDevice
						VirtualDevice aVirtualDevice(*Application::GetDefaultDevice());
						const Size aSizePixel(nSizeX, nSizeY);
						aVirtualDevice.SetOutputSizePixel(aSizePixel);

						// set size at control
						xControlWindow->setPosSize(0, 0, nSizeX, nSizeY, awt::PosSize::POSSIZE);

						// get graphics and view
						uno::Reference< awt::XGraphics > xGraphics(aVirtualDevice.CreateUnoGraphics());
						uno::Reference< awt::XView > xControlView(rXControl, uno::UNO_QUERY);

						if(xGraphics.is() && xControlView.is())
						{
							// link graphics and view
							xControlView->setGraphics(xGraphics);

                            {   // #i93162# For painting the control setting a Zoom (using setZoom() at the xControlView)
                                // is needed to define the font size. Normally this is done in
                                // ViewObjectContactOfUnoControl::createPrimitive2DSequence by using positionControlForPaint().
                                // For some reason the difference between MAP_TWIPS and MAP_100TH_MM still plays
                                // a role there so that for Draw/Impress/Calc (the MAP_100TH_MM users) i need to set a zoom
                                // here, too. The factor includes the needed scale, but is calculated by pure comparisons. It
                                // is somehow related to the twips/100thmm relationship.
                                bool bUserIs100thmm(false);
            				    const uno::Reference< awt::XControl > xControl(xControlView, uno::UNO_QUERY);

                                if(xControl.is())
                                {
                                    uno::Reference< awt::XWindowPeer > xWindowPeer(xControl->getPeer());

                                    if(xWindowPeer.is())
                                    {
                    			        VCLXWindow* pVCLXWindow = VCLXWindow::GetImplementation(xWindowPeer);

                                        if(pVCLXWindow)
                                        {
                                            Window* pWindow = pVCLXWindow->GetWindow();

                                            if(pWindow)
                                            {
                                                pWindow = pWindow->GetParent();

                                                if(pWindow)
                                                {
                                                    if(MAP_100TH_MM == pWindow->GetMapMode().GetMapUnit())
                                                    {
                                                        bUserIs100thmm = true;
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }

                                if(bUserIs100thmm)
                                {
					                // calc screen zoom for text display. fFactor is already added indirectly in aDiscreteSize
					                basegfx::B2DVector aScreenZoom(
						                basegfx::fTools::equalZero(aScale.getX()) ? 1.0 : aDiscreteSize.getX() / aScale.getX(),
						                basegfx::fTools::equalZero(aScale.getY()) ? 1.0 : aDiscreteSize.getY() / aScale.getY());
					                static double fZoomScale(28.0); // do not ask for this constant factor, but it gets the zoom right
                                    aScreenZoom *= fZoomScale;

                                    // set zoom at control view for text scaling
	    			                xControlView->setZoom((float)aScreenZoom.getX(), (float)aScreenZoom.getY());
                                }
                            }

							try
							{
								// try to paint it to VirtualDevice
								xControlView->draw(0, 0);

								// get bitmap
							    const Bitmap aContent(aVirtualDevice.GetBitmap(Point(), aSizePixel));

                                // to avoid scaling, use the Bitmap pixel size as primitive size
                                const Size aBitmapSize(aContent.GetSizePixel());
                                basegfx::B2DVector aBitmapSizeLogic(
                                    rViewInformation.getInverseObjectToViewTransformation() *
                                    basegfx::B2DVector(aBitmapSize.getWidth() - 1, aBitmapSize.getHeight() - 1));

                                if(bScaleUsed)
                                {
                                    // if scaled adapt to scaled size
                                    aBitmapSizeLogic /= fFactor;
                                }

                                // short form for scale and translate transformation
								const basegfx::B2DHomMatrix aBitmapTransform(basegfx::tools::createScaleTranslateB2DHomMatrix(
									aBitmapSizeLogic.getX(), aBitmapSizeLogic.getY(), aTranslate.getX(), aTranslate.getY()));

                                // create primitive
								xRetval = new BitmapPrimitive2D(BitmapEx(aContent), aBitmapTransform);
							}
							catch( const uno::Exception& )
							{
								DBG_UNHANDLED_EXCEPTION();
							}
						}
					}
				}
			}

			return xRetval;
		}

		Primitive2DReference ControlPrimitive2D::createPlaceholderDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
		{
			// create a gray placeholder hairline polygon in object size
			basegfx::B2DRange aObjectRange(0.0, 0.0, 1.0, 1.0);
			aObjectRange.transform(getTransform());
			const basegfx::B2DPolygon aOutline(basegfx::tools::createPolygonFromRect(aObjectRange));
			const basegfx::BColor aGrayTone(0xc0 / 255.0, 0xc0 / 255.0, 0xc0 / 255.0);

			// The replacement object may also get a text like 'empty group' here later
			Primitive2DReference xRetval(new PolygonHairlinePrimitive2D(aOutline, aGrayTone));

			return xRetval;
		}

		Primitive2DSequence ControlPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
		{
			// try to create a bitmap decomposition. If that fails for some reason,
			// at least create a replacement decomposition.
			Primitive2DReference xReference(createBitmapDecomposition(rViewInformation));

			if(!xReference.is())
			{
				xReference = createPlaceholderDecomposition(rViewInformation);
			}

			return Primitive2DSequence(&xReference, 1L);
		}

		ControlPrimitive2D::ControlPrimitive2D(
			const basegfx::B2DHomMatrix& rTransform,
			const uno::Reference< awt::XControlModel >& rxControlModel)
		:	BufferedDecompositionPrimitive2D(),
			maTransform(rTransform),
			mxControlModel(rxControlModel),
			mxXControl(),
			maLastViewScaling()
		{
		}

		ControlPrimitive2D::ControlPrimitive2D(
			const basegfx::B2DHomMatrix& rTransform,
			const uno::Reference< awt::XControlModel >& rxControlModel,
			const uno::Reference< awt::XControl >& rxXControl)
		:	BufferedDecompositionPrimitive2D(),
			maTransform(rTransform),
			mxControlModel(rxControlModel),
			mxXControl(rxXControl),
			maLastViewScaling()
		{
		}

		const uno::Reference< awt::XControl >& ControlPrimitive2D::getXControl() const
		{
			if(!mxXControl.is())
			{
				const_cast< ControlPrimitive2D* >(this)->createXControl();
			}

			return mxXControl;
		}

		bool ControlPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
		{
			// use base class compare operator
			if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
			{
				const ControlPrimitive2D& rCompare = (ControlPrimitive2D&)rPrimitive;

				if(getTransform() == rCompare.getTransform())
				{
                    // check if ControlModel references both are/are not
                    bool bRetval(getControlModel().is() == rCompare.getControlModel().is());

                    if(bRetval && getControlModel().is())
                    {
				        // both exist, check for equality
				        bRetval = (getControlModel() == rCompare.getControlModel());
                    }

                    if(bRetval)
                    {
                        // check if XControl references both are/are not
                        bRetval = (getXControl().is() == rCompare.getXControl().is());
                    }

                    if(bRetval && getXControl().is())
                    {
				        // both exist, check for equality
				        bRetval = (getXControl() == rCompare.getXControl());
                    }

                    return bRetval;
				}
			}

			return false;
		}

		basegfx::B2DRange ControlPrimitive2D::getB2DRange(const geometry::ViewInformation2D& /*rViewInformation*/) const
		{
			// simply derivate from unit range
			basegfx::B2DRange aRetval(0.0, 0.0, 1.0, 1.0);
			aRetval.transform(getTransform());
			return aRetval;
		}

		Primitive2DSequence ControlPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
		{
			// this primitive is view-dependent related to the scaling. If scaling has changed,
			// destroy existing decomposition. To detect change, use size of unit size in view coordinates
			::osl::MutexGuard aGuard( m_aMutex );
			const basegfx::B2DVector aNewScaling(rViewInformation.getObjectToViewTransformation() * basegfx::B2DVector(1.0, 1.0));

			if(getBuffered2DDecomposition().hasElements())
			{
				if(!maLastViewScaling.equal(aNewScaling))
				{
					// conditions of last local decomposition have changed, delete
					const_cast< ControlPrimitive2D* >(this)->setBuffered2DDecomposition(Primitive2DSequence());
				}
			}

			if(!getBuffered2DDecomposition().hasElements())
			{
				// remember ViewTransformation
				const_cast< ControlPrimitive2D* >(this)->maLastViewScaling = aNewScaling;
			}

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

		// provide unique ID
		ImplPrimitrive2DIDBlock(ControlPrimitive2D, PRIMITIVE2D_ID_CONTROLPRIMITIVE2D)

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

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