xref: /aoo41x/main/svx/source/sdr/contact/viewcontactofgraphic.cxx (revision c0d661f1)

/**************************************************************
 *
 * 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/contact/viewcontactofgraphic.hxx>
#include <svx/sdr/contact/viewobjectcontactofgraphic.hxx>
#include <svx/svdograf.hxx>
#include <svx/sdr/primitive2d/sdrattributecreator.hxx>
#include <svl/itemset.hxx>

#ifndef ITEMID_GRF_CROP
#define ITEMID_GRF_CROP	0
#endif

#include <svx/sdgcpitm.hxx>
#include <svx/sdr/contact/displayinfo.hxx>
#include <svx/sdr/contact/viewobjectcontact.hxx>
#include <svx/sdr/contact/objectcontact.hxx>
#include <svx/sdr/event/eventhandler.hxx>
#include <basegfx/matrix/b2dhommatrix.hxx>
#include <svx/sdr/primitive2d/sdrgrafprimitive2d.hxx>
#include "svx/svdstr.hrc"
#include <svx/svdglob.hxx>
#include <vcl/svapp.hxx>
#include <basegfx/polygon/b2dpolygontools.hxx>
#include <drawinglayer/primitive2d/polygonprimitive2d.hxx>
#include <drawinglayer/primitive2d/bitmapprimitive2d.hxx>
#include <drawinglayer/primitive2d/textprimitive2d.hxx>
#include <drawinglayer/primitive2d/textlayoutdevice.hxx>
#include <drawinglayer/primitive2d/maskprimitive2d.hxx>
#include <svx/sdr/primitive2d/sdrtextprimitive2d.hxx>
#include <editeng/eeitem.hxx>
#include <editeng/colritem.hxx>
#include <basegfx/matrix/b2dhommatrixtools.hxx>
#include <drawinglayer/primitive2d/sdrdecompositiontools2d.hxx>

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

namespace sdr
{
	namespace contact
	{
		// Create a Object-Specific ViewObjectContact, set ViewContact and
		// ObjectContact. Always needs to return something.
		ViewObjectContact& ViewContactOfGraphic::CreateObjectSpecificViewObjectContact(ObjectContact& rObjectContact)
		{
			ViewObjectContact* pRetval = new ViewObjectContactOfGraphic(rObjectContact, *this);
			DBG_ASSERT(pRetval, "ViewContact::CreateObjectSpecificViewObjectContact() failed (!)");

			return *pRetval;
		}

		ViewContactOfGraphic::ViewContactOfGraphic(SdrGrafObj& rGrafObj)
		:	ViewContactOfTextObj(rGrafObj)
		{
		}

		ViewContactOfGraphic::~ViewContactOfGraphic()
		{
		}

		void ViewContactOfGraphic::flushGraphicObjects()
		{
			// #i102380# The graphic is swapped out. To let that have an effect ist is necessary to
			// delete copies of the GraphicObject which are not swapped out and have no SwapHandler set
			// (this is what happnes when the GraphicObject gets copied to a SdrGrafPrimitive2D). This
			// is best achieved for the VC by clearing the local decomposition cache. It would be possible
			// to also do this for the VOC cache, but that VOCs exist exactly expresss that the object
			// gets visualised, so this would be wrong.
			flushViewIndependentPrimitive2DSequence();
		}

		drawinglayer::primitive2d::Primitive2DSequence ViewContactOfGraphic::createVIP2DSForPresObj(
			const basegfx::B2DHomMatrix& rObjectMatrix,
			const drawinglayer::attribute::SdrLineFillShadowTextAttribute& rAttribute) const
		{
			drawinglayer::primitive2d::Primitive2DSequence xRetval;
            GraphicObject aEmptyGraphicObject;
			GraphicAttr	aEmptyGraphicAttr;

            // SdrGrafPrimitive2D without content in original size which carries all eventual attributes and texts
            const drawinglayer::primitive2d::Primitive2DReference xReferenceA(new drawinglayer::primitive2d::SdrGrafPrimitive2D(
			    rObjectMatrix,
				rAttribute,
				aEmptyGraphicObject,
				aEmptyGraphicAttr));
		    xRetval = drawinglayer::primitive2d::Primitive2DSequence(&xReferenceA, 1);

            // SdrGrafPrimitive2D with content (which is the preview graphic) scaled to smaller size and
            // without attributes
            basegfx::B2DHomMatrix aSmallerMatrix;

            // #i94431# for some reason, i forgot to take the PrefMapMode of the graphic
            // into account. Since EmptyPresObj's are only used in Draw/Impress, it is
            // safe to assume 100th mm as target.
			Size aPrefSize(GetGrafObject().GetGrafPrefSize());

            if(MAP_PIXEL == GetGrafObject().GetGrafPrefMapMode().GetMapUnit())
            {
                aPrefSize = Application::GetDefaultDevice()->PixelToLogic(aPrefSize, MAP_100TH_MM);
            }
            else
            {
                aPrefSize = Application::GetDefaultDevice()->LogicToLogic(aPrefSize, GetGrafObject().GetGrafPrefMapMode(), MAP_100TH_MM);
            }

			// decompose object matrix to get single values
			basegfx::B2DVector aScale, aTranslate;
			double fRotate, fShearX;
			rObjectMatrix.decompose(aScale, aTranslate, fRotate, fShearX);

			const double fOffsetX((aScale.getX() - aPrefSize.getWidth()) / 2.0);
            const double fOffsetY((aScale.getY() - aPrefSize.getHeight()) / 2.0);

            if(basegfx::fTools::moreOrEqual(fOffsetX, 0.0) && basegfx::fTools::moreOrEqual(fOffsetY, 0.0))
            {
				// create the EmptyPresObj fallback visualisation. The fallback graphic
				// is already provided in rGraphicObject in this case, use it
				aSmallerMatrix = basegfx::tools::createScaleTranslateB2DHomMatrix(aPrefSize.getWidth(), aPrefSize.getHeight(), fOffsetX, fOffsetY);
				aSmallerMatrix = basegfx::tools::createShearXRotateTranslateB2DHomMatrix(fShearX, fRotate, aTranslate)
					* aSmallerMatrix;

				const GraphicObject& rGraphicObject = GetGrafObject().GetGraphicObject(false);
                const GraphicAttr aLocalGrafInfo;
                const drawinglayer::primitive2d::Primitive2DReference xReferenceB(new drawinglayer::primitive2d::SdrGrafPrimitive2D(
                    aSmallerMatrix,
                    drawinglayer::attribute::SdrLineFillShadowTextAttribute(),
                    rGraphicObject,
                    aLocalGrafInfo));

                drawinglayer::primitive2d::appendPrimitive2DReferenceToPrimitive2DSequence(xRetval, xReferenceB);
            }

			return xRetval;
		}

		drawinglayer::primitive2d::Primitive2DSequence ViewContactOfGraphic::createVIP2DSForDraft(
			const basegfx::B2DHomMatrix& rObjectMatrix,
			const drawinglayer::attribute::SdrLineFillShadowTextAttribute& rAttribute) const
		{
			drawinglayer::primitive2d::Primitive2DSequence xRetval;
            GraphicObject aEmptyGraphicObject;
			GraphicAttr	aEmptyGraphicAttr;

            // SdrGrafPrimitive2D without content in original size which carries all eventual attributes and texts
            const drawinglayer::primitive2d::Primitive2DReference xReferenceA(new drawinglayer::primitive2d::SdrGrafPrimitive2D(
			    rObjectMatrix,
				rAttribute,
				aEmptyGraphicObject,
				aEmptyGraphicAttr));
		    xRetval = drawinglayer::primitive2d::Primitive2DSequence(&xReferenceA, 1);

			if(rAttribute.getLine().isDefault())
			{
				// create a surrounding frame when no linestyle given
		        const Color aColor(Application::GetSettings().GetStyleSettings().GetShadowColor());
				const basegfx::BColor aBColor(aColor.getBColor());
				basegfx::B2DPolygon aOutline(basegfx::tools::createUnitPolygon());
				aOutline.transform(rObjectMatrix);

				drawinglayer::primitive2d::appendPrimitive2DReferenceToPrimitive2DSequence(xRetval,
					drawinglayer::primitive2d::Primitive2DReference(
						new drawinglayer::primitive2d::PolygonHairlinePrimitive2D(
							aOutline,
							aBColor)));
			}

			// decompose object matrix to get single values
			basegfx::B2DVector aScale, aTranslate;
			double fRotate, fShearX;
			rObjectMatrix.decompose(aScale, aTranslate, fRotate, fShearX);

			// define a distance value, used for distance from bitmap to borders and from bitmap
			// to text, too (2 mm)
			const double fDistance(200.0);

			// consume borders from values
			aScale.setX(std::max(0.0, aScale.getX() - (2.0 * fDistance)));
			aScale.setY(std::max(0.0, aScale.getY() - (2.0 * fDistance)));
			aTranslate.setX(aTranslate.getX() + fDistance);
			aTranslate.setY(aTranslate.getY() + fDistance);

			// draw a draft bitmap
			const Bitmap aDraftBitmap(ResId(BMAP_GrafikEi, *ImpGetResMgr()));

			if(!aDraftBitmap.IsEmpty())
			{
				Size aPrefSize(aDraftBitmap.GetPrefSize());

				if(MAP_PIXEL == aDraftBitmap.GetPrefMapMode().GetMapUnit())
				{
					aPrefSize = Application::GetDefaultDevice()->PixelToLogic(aDraftBitmap.GetSizePixel(), MAP_100TH_MM);
				}
				else
				{
					aPrefSize = Application::GetDefaultDevice()->LogicToLogic(aPrefSize, aDraftBitmap.GetPrefMapMode(), MAP_100TH_MM);
				}

                const double fBitmapScaling(2.0);
				const double fWidth(aPrefSize.getWidth() * fBitmapScaling);
				const double fHeight(aPrefSize.getHeight() * fBitmapScaling);

				if(basegfx::fTools::more(fWidth, 1.0)
					&& basegfx::fTools::more(fHeight, 1.0)
					&& basegfx::fTools::lessOrEqual(fWidth, aScale.getX())
					&& basegfx::fTools::lessOrEqual(fHeight, aScale.getY()))
				{
					const basegfx::B2DHomMatrix aBitmapMatrix(basegfx::tools::createScaleShearXRotateTranslateB2DHomMatrix(
						fWidth, fHeight, fShearX, fRotate, aTranslate.getX(), aTranslate.getY()));

					drawinglayer::primitive2d::appendPrimitive2DReferenceToPrimitive2DSequence(xRetval,
						drawinglayer::primitive2d::Primitive2DReference(
							new drawinglayer::primitive2d::BitmapPrimitive2D(
								BitmapEx(aDraftBitmap),
								aBitmapMatrix)));

					// consume bitmap size in X
					aScale.setX(std::max(0.0, aScale.getX() - (fWidth + fDistance)));
					aTranslate.setX(aTranslate.getX() + fWidth + fDistance);
				}
			}

			// Build the text for the draft object
			XubString aDraftText = GetGrafObject().GetFileName();

			if(!aDraftText.Len())
			{
				aDraftText = GetGrafObject().GetName();
				aDraftText.AppendAscii(" ...");
			}

			if(aDraftText.Len() && GetGrafObject().GetModel())
			{
                // #i103255# Goal is to produce TextPrimitives which hold the given text as
                // BlockText in the available space. It would be very tricky to do
                // an own word wrap/line layout here.
                // Using SdrBlockTextPrimitive2D OTOH is critical since it internally
                // uses the SdrObject it references. To solve this, create a temp
                // SdrObject with Attributes and Text, generate a SdrBlockTextPrimitive2D
                // directly and immediately decompose it. After that, it is no longer
                // needed and can be deleted.

                // create temp RectObj as TextObj and set needed attributes
                SdrRectObj aRectObj(OBJ_TEXT);
                aRectObj.SetModel(GetGrafObject().GetModel());
                aRectObj.NbcSetText(aDraftText);
                aRectObj.SetMergedItem(SvxColorItem(Color(COL_LIGHTRED), EE_CHAR_COLOR));

                // get SdrText and OPO
                SdrText* pSdrText = aRectObj.getText(0);
                OutlinerParaObject* pOPO = aRectObj.GetOutlinerParaObject();

                if(pSdrText && pOPO)
                {
                    // directly use the remaining space as TextRangeTransform
					const basegfx::B2DHomMatrix aTextRangeTransform(basegfx::tools::createScaleShearXRotateTranslateB2DHomMatrix(
						aScale, fShearX, fRotate, aTranslate));

                    // directly create temp SdrBlockTextPrimitive2D
                    drawinglayer::primitive2d::SdrBlockTextPrimitive2D aBlockTextPrimitive(
                        pSdrText,
                        *pOPO,
                        aTextRangeTransform,
                        SDRTEXTHORZADJUST_LEFT,
                        SDRTEXTVERTADJUST_TOP,
                        false,
                        false,
                        false,
                        false,
						false);

                    // decompose immediately with neutral ViewInformation. This will
                    // layout the text to more simple TextPrimitives from drawinglayer
                    const drawinglayer::geometry::ViewInformation2D aViewInformation2D;

                    drawinglayer::primitive2d::appendPrimitive2DSequenceToPrimitive2DSequence(
                        xRetval,
                        aBlockTextPrimitive.get2DDecomposition(aViewInformation2D));
                }
            }

			return xRetval;
		}

		drawinglayer::primitive2d::Primitive2DSequence ViewContactOfGraphic::createViewIndependentPrimitive2DSequence() const
		{
			drawinglayer::primitive2d::Primitive2DSequence xRetval;
			const SfxItemSet& rItemSet = GetGrafObject().GetMergedItemSet();

			// create and fill GraphicAttr
			GraphicAttr	aLocalGrafInfo;
			const sal_uInt16 nTrans(((SdrGrafTransparenceItem&)rItemSet.Get(SDRATTR_GRAFTRANSPARENCE)).GetValue());
			const SdrGrafCropItem& rCrop((const SdrGrafCropItem&)rItemSet.Get(SDRATTR_GRAFCROP));
			aLocalGrafInfo.SetLuminance(((SdrGrafLuminanceItem&)rItemSet.Get(SDRATTR_GRAFLUMINANCE)).GetValue());
			aLocalGrafInfo.SetContrast(((SdrGrafContrastItem&)rItemSet.Get(SDRATTR_GRAFCONTRAST)).GetValue());
			aLocalGrafInfo.SetChannelR(((SdrGrafRedItem&)rItemSet.Get(SDRATTR_GRAFRED)).GetValue());
			aLocalGrafInfo.SetChannelG(((SdrGrafGreenItem&)rItemSet.Get(SDRATTR_GRAFGREEN)).GetValue());
			aLocalGrafInfo.SetChannelB(((SdrGrafBlueItem&)rItemSet.Get(SDRATTR_GRAFBLUE)).GetValue());
			aLocalGrafInfo.SetGamma(((SdrGrafGamma100Item&)rItemSet.Get(SDRATTR_GRAFGAMMA)).GetValue() * 0.01);
			aLocalGrafInfo.SetTransparency((sal_uInt8)::basegfx::fround(Min(nTrans, (sal_uInt16)100) * 2.55));
			aLocalGrafInfo.SetInvert(((SdrGrafInvertItem&)rItemSet.Get(SDRATTR_GRAFINVERT)).GetValue());
			aLocalGrafInfo.SetDrawMode(((SdrGrafModeItem&)rItemSet.Get(SDRATTR_GRAFMODE)).GetValue());
			aLocalGrafInfo.SetCrop(rCrop.GetLeft(), rCrop.GetTop(), rCrop.GetRight(), rCrop.GetBottom());

            // we have content if graphic is not completely transparent
            const bool bHasContent(255L != aLocalGrafInfo.GetTransparency());
			drawinglayer::attribute::SdrLineFillShadowTextAttribute aAttribute(
				drawinglayer::primitive2d::createNewSdrLineFillShadowTextAttribute(
                    rItemSet,
                    GetGrafObject().getText(0),
                    bHasContent));

			// take unrotated snap rect for position and size. Directly use model data, not getBoundRect() or getSnapRect()
			// which will use the primitive data we just create in the near future
			const Rectangle& rRectangle = GetGrafObject().GetGeoRect();
			const ::basegfx::B2DRange aObjectRange(
                rRectangle.Left(), rRectangle.Top(),
                rRectangle.Right(), rRectangle.Bottom());

			// look for mirroring
			const GeoStat& rGeoStat(GetGrafObject().GetGeoStat());
			const sal_Int32 nDrehWink(rGeoStat.nDrehWink);
			const bool bRota180(18000 == nDrehWink);
			const bool bMirrored(GetGrafObject().IsMirrored());
			const sal_uInt16 nMirrorCase(bRota180 ? (bMirrored ? 3 : 4) : (bMirrored ? 2 : 1));
			bool bHMirr((2 == nMirrorCase ) || (4 == nMirrorCase));
			bool bVMirr((3 == nMirrorCase ) || (4 == nMirrorCase));

			// set mirror flags at LocalGrafInfo. Take into account that the geometry in
			// aObjectRange is already changed and rotated when bRota180 is used. To rebuild
			// that old behaviour (as long as part of the model data), correct the H/V flags
			// accordingly. The created bitmapPrimitive WILL use the rotation, too.
			if(bRota180)
			{
				// if bRota180 which is used for vertical mirroring, the graphic will already be rotated
				// by 180 degrees. To correct, switch off VMirror and invert HMirroring.
				bHMirr = !bHMirr;
				bVMirr = false;
			}

			if(bHMirr || bVMirr)
			{
				aLocalGrafInfo.SetMirrorFlags((bHMirr ? BMP_MIRROR_HORZ : 0)|(bVMirr ? BMP_MIRROR_VERT : 0));
			}

			// fill object matrix
            const double fShearX(rGeoStat.nShearWink ? tan((36000 - rGeoStat.nShearWink) * F_PI18000) : 0.0);
            const double fRotate(nDrehWink ? (36000 - nDrehWink) * F_PI18000 : 0.0);
			const basegfx::B2DHomMatrix aObjectMatrix(basegfx::tools::createScaleShearXRotateTranslateB2DHomMatrix(
				aObjectRange.getWidth(), aObjectRange.getHeight(),
				fShearX, fRotate,
				aObjectRange.getMinX(), aObjectRange.getMinY()));

			// get the current, unchenged graphic obect from SdrGrafObj
			const GraphicObject& rGraphicObject = GetGrafObject().GetGraphicObject(false);

			if(visualisationUsesPresObj())
            {
                // it's an EmptyPresObj, create the SdrGrafPrimitive2D without content and another scaled one
                // with the content which is the placeholder graphic
				xRetval = createVIP2DSForPresObj(aObjectMatrix, aAttribute);
            }
            else if(visualisationUsesDraft())
            {
			    // #i102380# The graphic is swapped out. To not force a swap-in here, there is a mechanism
			    // which shows a swapped-out-visualisation (which gets created here now) and an asynchronious
			    // visual update mechanism for swapped-out grapgics when they were loaded (see AsynchGraphicLoadingEvent
			    // and ViewObjectContactOfGraphic implementation). Not forcing the swap-in here allows faster
			    // (non-blocking) processing here and thus in the effect e.g. fast scrolling through pages
			    xRetval = createVIP2DSForDraft(aObjectMatrix, aAttribute);
            }
            else
            {
                // create primitive. Info: Calling the copy-constructor of GraphicObject in this
                // SdrGrafPrimitive2D constructor will force a full swap-in of the graphic
                const drawinglayer::primitive2d::Primitive2DReference xReference(
                    new drawinglayer::primitive2d::SdrGrafPrimitive2D(
                        aObjectMatrix,
                        aAttribute,
                        rGraphicObject,
                        aLocalGrafInfo));

                xRetval = drawinglayer::primitive2d::Primitive2DSequence(&xReference, 1);
            }

			// always append an invisible outline for the cases where no visible content exists
			drawinglayer::primitive2d::appendPrimitive2DReferenceToPrimitive2DSequence(xRetval,
				drawinglayer::primitive2d::createHiddenGeometryPrimitives2D(
					false, aObjectMatrix));

			return xRetval;
		}

        bool ViewContactOfGraphic::visualisationUsesPresObj() const
        {
            return GetGrafObject().IsEmptyPresObj();
        }

        bool ViewContactOfGraphic::visualisationUsesDraft() const
        {
            // no draft when already PresObj
            if(visualisationUsesPresObj())
                return false;

            // draft when swapped out
			const GraphicObject& rGraphicObject = GetGrafObject().GetGraphicObject(false);
            static bool bAllowReplacements(true);

            if(rGraphicObject.IsSwappedOut() && bAllowReplacements)
                return true;

            // draft when no graphic
            if(GRAPHIC_NONE == rGraphicObject.GetType() || GRAPHIC_DEFAULT == rGraphicObject.GetType())
               return true;

            return false;
        }

	} // end of namespace contact
} // end of namespace sdr

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