/************************************************************** * * 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. * *************************************************************/ #include "precompiled_svx.hxx" #include #include #include #include #include #include ////////////////////////////////////////////////////////////////////////////// using namespace com::sun::star; ////////////////////////////////////////////////////////////////////////////// namespace drawinglayer { namespace primitive2d { SdrOle2Primitive2D::SdrOle2Primitive2D( const Primitive2DSequence& rOLEContent, const basegfx::B2DHomMatrix& rTransform, const attribute::SdrLineFillShadowTextAttribute& rSdrLFSTAttribute) : BasePrimitive2D(), maOLEContent(rOLEContent), maTransform(rTransform), maSdrLFSTAttribute(rSdrLFSTAttribute) { } bool SdrOle2Primitive2D::operator==(const BasePrimitive2D& rPrimitive) const { if(BasePrimitive2D::operator==(rPrimitive)) { const SdrOle2Primitive2D& rCompare = (SdrOle2Primitive2D&)rPrimitive; // #i108636# The standard operator== on two UNO sequences did not work as i // would have expected; it just checks the .is() states and the data type // of the sequence. What i need here is detection of equality of the whole // sequence content, thus i need to use the arePrimitive2DSequencesEqual helper // here instead of the operator== which lead to always returning false and thus // always re-decompositions of the subcontent. if(arePrimitive2DSequencesEqual(getOLEContent(), rCompare.getOLEContent()) && getTransform() == rCompare.getTransform() && getSdrLFSTAttribute() == rCompare.getSdrLFSTAttribute()) { return true; } } return false; } Primitive2DSequence SdrOle2Primitive2D::get2DDecomposition(const geometry::ViewInformation2D& /*aViewInformation*/) const { // to take care of getSdrLFSTAttribute() later, the same as in SdrGrafPrimitive2D::create2DDecomposition // should happen. For the moment we only need the OLE itself // Added complete primitive preparation using getSdrLFSTAttribute() now. To not do stuff which is not needed now, it // may be supressed by using a static bool. The paint version only supported text. static bool bBehaveCompatibleToPaintVersion(false); Primitive2DSequence aRetval; // create unit outline polygon const basegfx::B2DPolygon aUnitOutline(basegfx::tools::createUnitPolygon()); // add fill if(!bBehaveCompatibleToPaintVersion && !getSdrLFSTAttribute().getFill().isDefault()) { appendPrimitive2DReferenceToPrimitive2DSequence(aRetval, createPolyPolygonFillPrimitive( basegfx::B2DPolyPolygon(aUnitOutline), getTransform(), getSdrLFSTAttribute().getFill(), getSdrLFSTAttribute().getFillFloatTransGradient())); } // add line // #i97981# condition was inverse to purpose. When being compatible to paint version, // border needs to be suppressed if(!bBehaveCompatibleToPaintVersion && !getSdrLFSTAttribute().getLine().isDefault()) { // if line width is given, polygon needs to be grown by half of it to make the // outline to be outside of the bitmap if(0.0 != getSdrLFSTAttribute().getLine().getWidth()) { // decompose to get scale basegfx::B2DVector aScale, aTranslate; double fRotate, fShearX; getTransform().decompose(aScale, aTranslate, fRotate, fShearX); // create expanded range (add relative half line width to unit rectangle) double fHalfLineWidth(getSdrLFSTAttribute().getLine().getWidth() * 0.5); double fScaleX(0.0 != aScale.getX() ? fHalfLineWidth / fabs(aScale.getX()) : 1.0); double fScaleY(0.0 != aScale.getY() ? fHalfLineWidth / fabs(aScale.getY()) : 1.0); const basegfx::B2DRange aExpandedRange(-fScaleX, -fScaleY, 1.0 + fScaleX, 1.0 + fScaleY); basegfx::B2DPolygon aExpandedUnitOutline(basegfx::tools::createPolygonFromRect(aExpandedRange)); appendPrimitive2DReferenceToPrimitive2DSequence(aRetval, createPolygonLinePrimitive( aExpandedUnitOutline, getTransform(), getSdrLFSTAttribute().getLine(), attribute::SdrLineStartEndAttribute())); } else { appendPrimitive2DReferenceToPrimitive2DSequence(aRetval, createPolygonLinePrimitive( aUnitOutline, getTransform(), getSdrLFSTAttribute().getLine(), attribute::SdrLineStartEndAttribute())); } } else { // if initially no line is defined, create one for HitTest and BoundRect appendPrimitive2DReferenceToPrimitive2DSequence(aRetval, createHiddenGeometryPrimitives2D( false, basegfx::B2DPolyPolygon(aUnitOutline), getTransform())); } // add graphic content appendPrimitive2DSequenceToPrimitive2DSequence(aRetval, getOLEContent()); // add text, no need to supress to stay compatible since text was // always supported by the old paints, too if(!getSdrLFSTAttribute().getText().isDefault()) { appendPrimitive2DReferenceToPrimitive2DSequence(aRetval, createTextPrimitive( basegfx::B2DPolyPolygon(aUnitOutline), getTransform(), getSdrLFSTAttribute().getText(), getSdrLFSTAttribute().getLine(), false, false, false)); } // add shadow if(!bBehaveCompatibleToPaintVersion && !getSdrLFSTAttribute().getShadow().isDefault()) { aRetval = createEmbeddedShadowPrimitive( aRetval, getSdrLFSTAttribute().getShadow()); } return aRetval; } // provide unique ID ImplPrimitrive2DIDBlock(SdrOle2Primitive2D, PRIMITIVE2D_ID_SDROLE2PRIMITIVE2D) } // end of namespace primitive2d } // end of namespace drawinglayer ////////////////////////////////////////////////////////////////////////////// // eof