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