1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_drawinglayer.hxx" 26 27 #include <drawinglayer/processor2d/vclprocessor2d.hxx> 28 #include <drawinglayer/primitive2d/textprimitive2d.hxx> 29 #include <drawinglayer/primitive2d/textdecoratedprimitive2d.hxx> 30 #include <tools/debug.hxx> 31 #include <vcl/outdev.hxx> 32 #include <drawinglayer/primitive2d/polygonprimitive2d.hxx> 33 #include <drawinglayer/primitive2d/bitmapprimitive2d.hxx> 34 #include <basegfx/polygon/b2dpolygontools.hxx> 35 #include <drawinglayer/attribute/sdrfillgraphicattribute.hxx> 36 #include <drawinglayer/primitive2d/fillgraphicprimitive2d.hxx> 37 #include <drawinglayer/primitive2d/polypolygonprimitive2d.hxx> 38 #include <drawinglayer/primitive2d/metafileprimitive2d.hxx> 39 #include <drawinglayer/primitive2d/maskprimitive2d.hxx> 40 #include <basegfx/polygon/b2dpolypolygontools.hxx> 41 #include <vclhelperbufferdevice.hxx> 42 #include <drawinglayer/primitive2d/modifiedcolorprimitive2d.hxx> 43 #include <drawinglayer/primitive2d/unifiedtransparenceprimitive2d.hxx> 44 #include <drawinglayer/primitive2d/transparenceprimitive2d.hxx> 45 #include <drawinglayer/primitive2d/transformprimitive2d.hxx> 46 #include <drawinglayer/primitive2d/markerarrayprimitive2d.hxx> 47 #include <drawinglayer/primitive2d/pointarrayprimitive2d.hxx> 48 #include <drawinglayer/primitive2d/wrongspellprimitive2d.hxx> 49 #include <svl/ctloptions.hxx> 50 #include <vcl/svapp.hxx> 51 #include <drawinglayer/primitive2d/pagepreviewprimitive2d.hxx> 52 #include <tools/diagnose_ex.h> 53 #include <vcl/metric.hxx> 54 #include <drawinglayer/primitive2d/textenumsprimitive2d.hxx> 55 #include <drawinglayer/primitive2d/epsprimitive2d.hxx> 56 #include <drawinglayer/primitive2d/svggradientprimitive2d.hxx> 57 #include <basegfx/color/bcolor.hxx> 58 #include <basegfx/matrix/b2dhommatrixtools.hxx> 59 #include <vcl/graph.hxx> 60 61 ////////////////////////////////////////////////////////////////////////////// 62 // control support 63 64 #include <com/sun/star/awt/XWindow2.hpp> 65 #include <com/sun/star/awt/PosSize.hpp> 66 #include <com/sun/star/awt/XView.hpp> 67 #include <drawinglayer/primitive2d/controlprimitive2d.hxx> 68 #include <drawinglayer/primitive2d/textlayoutdevice.hxx> 69 70 ////////////////////////////////////////////////////////////////////////////// 71 // for test, can be removed again 72 73 #include <basegfx/polygon/b2dpolygonclipper.hxx> 74 #include <basegfx/polygon/b2dtrapezoid.hxx> 75 76 ////////////////////////////////////////////////////////////////////////////// 77 78 using namespace com::sun::star; 79 80 ////////////////////////////////////////////////////////////////////////////// 81 82 namespace 83 { calculateStepsForSvgGradient(const basegfx::BColor & rColorA,const basegfx::BColor & rColorB,double fDelta,double fDiscreteUnit)84 sal_uInt32 calculateStepsForSvgGradient(const basegfx::BColor& rColorA, const basegfx::BColor& rColorB, double fDelta, double fDiscreteUnit) 85 { 86 // use color distance, assume to do every color step 87 sal_uInt32 nSteps(basegfx::fround(rColorA.getDistance(rColorB) * 255.0)); 88 89 if(nSteps) 90 { 91 // calc discrete length to change color each disctete unit (pixel) 92 const sal_uInt32 nDistSteps(basegfx::fround(fDelta / fDiscreteUnit)); 93 94 nSteps = std::min(nSteps, nDistSteps); 95 } 96 97 // reduce quality to 3 discrete units or every 3rd color step for rendering 98 nSteps /= 2; 99 100 // roughly cut when too big or too small (not full quality, reduce complexity) 101 nSteps = std::min(nSteps, sal_uInt32(255)); 102 nSteps = std::max(nSteps, sal_uInt32(1)); 103 104 return nSteps; 105 } 106 } // end of anonymous namespace 107 108 ////////////////////////////////////////////////////////////////////////////// 109 110 namespace drawinglayer 111 { 112 namespace processor2d 113 { 114 ////////////////////////////////////////////////////////////////////////////// 115 // UNO class usages 116 using ::com::sun::star::uno::Reference; 117 using ::com::sun::star::uno::UNO_QUERY; 118 using ::com::sun::star::uno::UNO_QUERY_THROW; 119 using ::com::sun::star::uno::Exception; 120 using ::com::sun::star::awt::XView; 121 using ::com::sun::star::awt::XGraphics; 122 using ::com::sun::star::awt::XWindow; 123 using ::com::sun::star::awt::PosSize::POSSIZE; 124 125 ////////////////////////////////////////////////////////////////////////////// 126 // rendering support 127 128 // directdraw of text simple portion or decorated portion primitive. When decorated, all the extra 129 // information is translated to VCL parameters and set at the font. 130 // Acceptance is restricted to no shearing and positive scaling in X and Y (no font mirroring 131 // for VCL) RenderTextSimpleOrDecoratedPortionPrimitive2D(const primitive2d::TextSimplePortionPrimitive2D & rTextCandidate)132 void VclProcessor2D::RenderTextSimpleOrDecoratedPortionPrimitive2D(const primitive2d::TextSimplePortionPrimitive2D& rTextCandidate) 133 { 134 // decompose matrix to have position and size of text 135 basegfx::B2DHomMatrix aLocalTransform(maCurrentTransformation * rTextCandidate.getTextTransform()); 136 basegfx::B2DVector aFontScaling, aTranslate; 137 double fRotate, fShearX; 138 aLocalTransform.decompose(aFontScaling, aTranslate, fRotate, fShearX); 139 bool bPrimitiveAccepted(false); 140 141 if(basegfx::fTools::equalZero(fShearX)) 142 { 143 if(basegfx::fTools::less(aFontScaling.getX(), 0.0) && basegfx::fTools::less(aFontScaling.getY(), 0.0)) 144 { 145 // handle special case: If scale is negative in (x,y) (3rd quadrant), it can 146 // be expressed as rotation by PI. Use this since the Font rendering will not 147 // apply the negative scales in any form 148 aFontScaling = basegfx::absolute(aFontScaling); 149 fRotate += F_PI; 150 } 151 152 if(basegfx::fTools::more(aFontScaling.getX(), 0.0) && basegfx::fTools::more(aFontScaling.getY(), 0.0)) 153 { 154 // Get the VCL font (use FontHeight as FontWidth) 155 Font aFont(primitive2d::getVclFontFromFontAttribute( 156 rTextCandidate.getFontAttribute(), 157 aFontScaling.getX(), 158 aFontScaling.getY(), 159 fRotate, 160 rTextCandidate.getLocale())); 161 162 // handle additional font attributes 163 const primitive2d::TextDecoratedPortionPrimitive2D* pTCPP = 164 dynamic_cast<const primitive2d::TextDecoratedPortionPrimitive2D*>( &rTextCandidate ); 165 166 if( pTCPP != NULL ) 167 { 168 169 // set the color of text decorations 170 const basegfx::BColor aTextlineColor = maBColorModifierStack.getModifiedColor(pTCPP->getTextlineColor()); 171 mpOutputDevice->SetTextLineColor( Color(aTextlineColor) ); 172 173 // set Overline attribute 174 const FontUnderline eFontOverline(primitive2d::mapTextLineToFontUnderline( pTCPP->getFontOverline() )); 175 if( eFontOverline != UNDERLINE_NONE ) 176 { 177 aFont.SetOverline( eFontOverline ); 178 const basegfx::BColor aOverlineColor = maBColorModifierStack.getModifiedColor(pTCPP->getOverlineColor()); 179 mpOutputDevice->SetOverlineColor( Color(aOverlineColor) ); 180 if( pTCPP->getWordLineMode() ) 181 aFont.SetWordLineMode( true ); 182 } 183 184 // set Underline attribute 185 const FontUnderline eFontUnderline(primitive2d::mapTextLineToFontUnderline( pTCPP->getFontUnderline() )); 186 if( eFontUnderline != UNDERLINE_NONE ) 187 { 188 aFont.SetUnderline( eFontUnderline ); 189 if( pTCPP->getWordLineMode() ) 190 aFont.SetWordLineMode( true ); 191 //TODO: ??? if( pTCPP->getUnderlineAbove() ) 192 // aFont.SetUnderlineAbove( true ); 193 } 194 195 // set Strikeout attribute 196 const FontStrikeout eFontStrikeout(primitive2d::mapTextStrikeoutToFontStrikeout(pTCPP->getTextStrikeout())); 197 198 if( eFontStrikeout != STRIKEOUT_NONE ) 199 aFont.SetStrikeout( eFontStrikeout ); 200 201 // set EmphasisMark attribute 202 FontEmphasisMark eFontEmphasisMark = EMPHASISMARK_NONE; 203 switch( pTCPP->getTextEmphasisMark() ) 204 { 205 default: 206 DBG_WARNING1( "DrawingLayer: Unknown EmphasisMark style (%d)!", pTCPP->getTextEmphasisMark() ); 207 // fall through 208 case primitive2d::TEXT_EMPHASISMARK_NONE: eFontEmphasisMark = EMPHASISMARK_NONE; break; 209 case primitive2d::TEXT_EMPHASISMARK_DOT: eFontEmphasisMark = EMPHASISMARK_DOT; break; 210 case primitive2d::TEXT_EMPHASISMARK_CIRCLE: eFontEmphasisMark = EMPHASISMARK_CIRCLE; break; 211 case primitive2d::TEXT_EMPHASISMARK_DISC: eFontEmphasisMark = EMPHASISMARK_DISC; break; 212 case primitive2d::TEXT_EMPHASISMARK_ACCENT: eFontEmphasisMark = EMPHASISMARK_ACCENT; break; 213 } 214 215 if( eFontEmphasisMark != EMPHASISMARK_NONE ) 216 { 217 DBG_ASSERT( (pTCPP->getEmphasisMarkAbove() != pTCPP->getEmphasisMarkBelow()), 218 "DrawingLayer: Bad EmphasisMark position!" ); 219 if( pTCPP->getEmphasisMarkAbove() ) 220 eFontEmphasisMark |= EMPHASISMARK_POS_ABOVE; 221 else 222 eFontEmphasisMark |= EMPHASISMARK_POS_BELOW; 223 aFont.SetEmphasisMark( eFontEmphasisMark ); 224 } 225 226 // set Relief attribute 227 FontRelief eFontRelief = RELIEF_NONE; 228 switch( pTCPP->getTextRelief() ) 229 { 230 default: 231 DBG_WARNING1( "DrawingLayer: Unknown Relief style (%d)!", pTCPP->getTextRelief() ); 232 // fall through 233 case primitive2d::TEXT_RELIEF_NONE: eFontRelief = RELIEF_NONE; break; 234 case primitive2d::TEXT_RELIEF_EMBOSSED: eFontRelief = RELIEF_EMBOSSED; break; 235 case primitive2d::TEXT_RELIEF_ENGRAVED: eFontRelief = RELIEF_ENGRAVED; break; 236 } 237 238 if( eFontRelief != RELIEF_NONE ) 239 aFont.SetRelief( eFontRelief ); 240 241 // set Shadow attribute 242 if( pTCPP->getShadow() ) 243 aFont.SetShadow( true ); 244 } 245 246 // create transformed integer DXArray in view coordinate system 247 ::std::vector< sal_Int32 > aTransformedDXArray; 248 249 if(rTextCandidate.getDXArray().size()) 250 { 251 aTransformedDXArray.reserve(rTextCandidate.getDXArray().size()); 252 const basegfx::B2DVector aPixelVector(maCurrentTransformation * basegfx::B2DVector(1.0, 0.0)); 253 const double fPixelVectorFactor(aPixelVector.getLength()); 254 255 for(::std::vector< double >::const_iterator aStart(rTextCandidate.getDXArray().begin()); 256 aStart != rTextCandidate.getDXArray().end(); aStart++) 257 { 258 aTransformedDXArray.push_back(basegfx::fround((*aStart) * fPixelVectorFactor)); 259 } 260 } 261 262 // set parameters and paint text snippet 263 const basegfx::BColor aRGBFontColor(maBColorModifierStack.getModifiedColor(rTextCandidate.getFontColor())); 264 const basegfx::B2DPoint aPoint(aLocalTransform * basegfx::B2DPoint(0.0, 0.0)); 265 const Point aStartPoint(basegfx::fround(aPoint.getX()), basegfx::fround(aPoint.getY())); 266 const sal_uInt32 nOldLayoutMode(mpOutputDevice->GetLayoutMode()); 267 268 if(rTextCandidate.getFontAttribute().getRTL()) 269 { 270 sal_uInt32 nRTLLayoutMode(nOldLayoutMode & ~(TEXT_LAYOUT_COMPLEX_DISABLED|TEXT_LAYOUT_BIDI_STRONG)); 271 nRTLLayoutMode |= TEXT_LAYOUT_BIDI_RTL|TEXT_LAYOUT_TEXTORIGIN_LEFT; 272 mpOutputDevice->SetLayoutMode(nRTLLayoutMode); 273 } 274 275 mpOutputDevice->SetFont(aFont); 276 mpOutputDevice->SetTextColor(Color(aRGBFontColor)); 277 278 if(aTransformedDXArray.size()) 279 { 280 mpOutputDevice->DrawTextArray( 281 aStartPoint, 282 rTextCandidate.getText(), 283 &(aTransformedDXArray[0]), 284 rTextCandidate.getTextPosition(), 285 rTextCandidate.getTextLength()); 286 } 287 else 288 { 289 mpOutputDevice->DrawText( 290 aStartPoint, 291 rTextCandidate.getText(), 292 rTextCandidate.getTextPosition(), 293 rTextCandidate.getTextLength()); 294 } 295 296 if(rTextCandidate.getFontAttribute().getRTL()) 297 { 298 mpOutputDevice->SetLayoutMode(nOldLayoutMode); 299 } 300 301 bPrimitiveAccepted = true; 302 } 303 } 304 305 if(!bPrimitiveAccepted) 306 { 307 // let break down 308 process(rTextCandidate.get2DDecomposition(getViewInformation2D())); 309 } 310 } 311 312 // direct draw of hairline RenderPolygonHairlinePrimitive2D(const primitive2d::PolygonHairlinePrimitive2D & rPolygonCandidate,bool bPixelBased)313 void VclProcessor2D::RenderPolygonHairlinePrimitive2D(const primitive2d::PolygonHairlinePrimitive2D& rPolygonCandidate, bool bPixelBased) 314 { 315 const basegfx::BColor aHairlineColor(maBColorModifierStack.getModifiedColor(rPolygonCandidate.getBColor())); 316 mpOutputDevice->SetLineColor(Color(aHairlineColor)); 317 mpOutputDevice->SetFillColor(); 318 319 basegfx::B2DPolygon aLocalPolygon(rPolygonCandidate.getB2DPolygon()); 320 aLocalPolygon.transform(maCurrentTransformation); 321 322 static bool bCheckTrapezoidDecomposition(false); 323 static bool bShowOutlinesThere(false); 324 if(bCheckTrapezoidDecomposition) 325 { 326 // clip against discrete ViewPort 327 const basegfx::B2DRange& rDiscreteViewport = getViewInformation2D().getDiscreteViewport(); 328 basegfx::B2DPolyPolygon aLocalPolyPolygon(basegfx::tools::clipPolygonOnRange( 329 aLocalPolygon, rDiscreteViewport, true, false)); 330 331 if(aLocalPolyPolygon.count()) 332 { 333 // subdivide 334 aLocalPolyPolygon = basegfx::tools::adaptiveSubdivideByDistance( 335 aLocalPolyPolygon, 0.5); 336 337 // trapezoidize 338 static double fLineWidth(2.0); 339 basegfx::B2DTrapezoidVector aB2DTrapezoidVector; 340 basegfx::tools::createLineTrapezoidFromB2DPolyPolygon(aB2DTrapezoidVector, aLocalPolyPolygon, fLineWidth); 341 342 const sal_uInt32 nCount(aB2DTrapezoidVector.size()); 343 344 if(nCount) 345 { 346 basegfx::BColor aInvPolygonColor(aHairlineColor); 347 aInvPolygonColor.invert(); 348 349 for(sal_uInt32 a(0); a < nCount; a++) 350 { 351 const basegfx::B2DPolygon aTempPolygon(aB2DTrapezoidVector[a].getB2DPolygon()); 352 353 if(bShowOutlinesThere) 354 { 355 mpOutputDevice->SetFillColor(Color(aHairlineColor)); 356 mpOutputDevice->SetLineColor(); 357 } 358 359 mpOutputDevice->DrawPolygon(aTempPolygon); 360 361 if(bShowOutlinesThere) 362 { 363 mpOutputDevice->SetFillColor(); 364 mpOutputDevice->SetLineColor(Color(aInvPolygonColor)); 365 mpOutputDevice->DrawPolyLine(aTempPolygon, 0.0); 366 } 367 } 368 } 369 } 370 } 371 else 372 { 373 if(bPixelBased && getOptionsDrawinglayer().IsAntiAliasing() && getOptionsDrawinglayer().IsSnapHorVerLinesToDiscrete()) 374 { 375 // #i98289# 376 // when a Hairline is painted and AntiAliasing is on the option SnapHorVerLinesToDiscrete 377 // allows to suppress AntiAliasing for pure horizontal or vertical lines. This is done since 378 // not-AntiAliased such lines look more pleasing to the eye (e.g. 2D chart content). This 379 // NEEDS to be done in discrete coordinates, so only useful for pixel based rendering. 380 aLocalPolygon = basegfx::tools::snapPointsOfHorizontalOrVerticalEdges(aLocalPolygon); 381 } 382 383 mpOutputDevice->DrawPolyLine(aLocalPolygon, 0.0); 384 } 385 } 386 387 // direct draw of transformed BitmapEx primitive RenderBitmapPrimitive2D(const primitive2d::BitmapPrimitive2D & rBitmapCandidate)388 void VclProcessor2D::RenderBitmapPrimitive2D(const primitive2d::BitmapPrimitive2D& rBitmapCandidate) 389 { 390 BitmapEx aBitmapEx(rBitmapCandidate.getBitmapEx()); 391 const basegfx::B2DHomMatrix aLocalTransform(maCurrentTransformation * rBitmapCandidate.getTransform()); 392 393 if(maBColorModifierStack.count()) 394 { 395 aBitmapEx = aBitmapEx.ModifyBitmapEx(maBColorModifierStack); 396 397 if(aBitmapEx.IsEmpty()) 398 { 399 // color gets completely replaced, get it 400 const basegfx::BColor aModifiedColor(maBColorModifierStack.getModifiedColor(basegfx::BColor())); 401 basegfx::B2DPolygon aPolygon(basegfx::tools::createUnitPolygon()); 402 aPolygon.transform(aLocalTransform); 403 404 mpOutputDevice->SetFillColor(Color(aModifiedColor)); 405 mpOutputDevice->SetLineColor(); 406 mpOutputDevice->DrawPolygon(aPolygon); 407 408 return; 409 } 410 } 411 412 // #122923# do no longer add Alpha channel here; the right place to do this is when really 413 // the own transformer is used (see OutputDevice::DrawTransformedBitmapEx). 414 415 // draw using OutputDevice'sDrawTransformedBitmapEx 416 mpOutputDevice->DrawTransformedBitmapEx(aLocalTransform, aBitmapEx); 417 } 418 RenderFillGraphicPrimitive2D(const primitive2d::FillGraphicPrimitive2D & rFillBitmapCandidate)419 void VclProcessor2D::RenderFillGraphicPrimitive2D(const primitive2d::FillGraphicPrimitive2D& rFillBitmapCandidate) 420 { 421 const attribute::FillGraphicAttribute& rFillGraphicAttribute(rFillBitmapCandidate.getFillGraphic()); 422 bool bPrimitiveAccepted(false); 423 static bool bTryTilingDirect = true; 424 425 // #121194# when tiling is used and content is bitmap-based, do direct tiling in the 426 // renderer on pixel base to ensure tight fitting. Do not do this when 427 // the fill is rotated or sheared. 428 429 // ovveride static bool (for debug) and tiling is active 430 if(bTryTilingDirect && rFillGraphicAttribute.getTiling()) 431 { 432 // content is bitmap(ex) 433 // 434 // for SVG support, force decomposition when SVG is present. This will lead to use 435 // the primitive representation of the svg directly. 436 // 437 // when graphic is animated, force decomposition to use the correct graphic, else 438 // fill style will not be animated 439 if(GRAPHIC_BITMAP == rFillGraphicAttribute.getGraphic().GetType() 440 && !rFillGraphicAttribute.getGraphic().getSvgData().get() 441 && !rFillGraphicAttribute.getGraphic().IsAnimated()) 442 { 443 // decompose matrix to check for shear, rotate and mirroring 444 basegfx::B2DHomMatrix aLocalTransform(maCurrentTransformation * rFillBitmapCandidate.getTransformation()); 445 basegfx::B2DVector aScale, aTranslate; 446 double fRotate, fShearX; 447 aLocalTransform.decompose(aScale, aTranslate, fRotate, fShearX); 448 449 // when nopt rotated/sheared 450 if(basegfx::fTools::equalZero(fRotate) && basegfx::fTools::equalZero(fShearX)) 451 { 452 // no shear or rotate, draw direct in pixel coordinates 453 bPrimitiveAccepted = true; 454 455 // transform object range to device coordinates (pixels). Use 456 // the device transformation for better accuracy 457 basegfx::B2DRange aObjectRange(aTranslate, aTranslate + aScale); 458 aObjectRange.transform(mpOutputDevice->GetViewTransformation()); 459 460 // extract discrete size of object 461 const sal_Int32 nOWidth(basegfx::fround(aObjectRange.getWidth())); 462 const sal_Int32 nOHeight(basegfx::fround(aObjectRange.getHeight())); 463 464 // only do something when object has a size in discrete units 465 if(nOWidth > 0 && nOHeight > 0) 466 { 467 // transform graphic range to device coordinates (pixels). Use 468 // the device transformation for better accuracy 469 basegfx::B2DRange aGraphicRange(rFillGraphicAttribute.getGraphicRange()); 470 aGraphicRange.transform(mpOutputDevice->GetViewTransformation() * aLocalTransform); 471 472 // extract discrete size of graphic 473 // caution: when getting to zero, nothing would be painted; thus, do not allow this 474 const sal_Int32 nBWidth(std::max(sal_Int32(1), basegfx::fround(aGraphicRange.getWidth()))); 475 const sal_Int32 nBHeight(std::max(sal_Int32(1), basegfx::fround(aGraphicRange.getHeight()))); 476 477 // only do something when bitmap fill has a size in discrete units 478 if(nBWidth > 0 && nBHeight > 0) 479 { 480 // nBWidth, nBHeight is the pixel size of the neede bitmap. To not need to scale it 481 // in vcl many times, create a size-optimized version 482 const Size aNeededBitmapSizePixel(nBWidth, nBHeight); 483 BitmapEx aBitmapEx(rFillGraphicAttribute.getGraphic().GetBitmapEx()); 484 static bool bEnablePreScaling(true); 485 const bool bPreScaled(bEnablePreScaling && nBWidth * nBHeight < (250 * 250)); 486 487 // ... but only up to a maximum size, else it gets too expensive 488 if(bPreScaled) 489 { 490 // if color depth is below 24bit, expand before scaling for better quality. 491 // This is even needed for low colors, else the scale will produce 492 // a bitmap in gray or Black/White (!) 493 if(aBitmapEx.GetBitCount() < 24) 494 { 495 aBitmapEx.Convert(BMP_CONVERSION_24BIT); 496 } 497 498 aBitmapEx.Scale(aNeededBitmapSizePixel, BMP_SCALE_INTERPOLATE); 499 } 500 501 bool bPainted(false); 502 503 if(maBColorModifierStack.count()) 504 { 505 // when color modifier, apply to bitmap 506 aBitmapEx = aBitmapEx.ModifyBitmapEx(maBColorModifierStack); 507 508 // impModifyBitmapEx uses empty bitmap as sign to return that 509 // the content will be completely replaced to mono color, use shortcut 510 if(aBitmapEx.IsEmpty()) 511 { 512 // color gets completely replaced, get it 513 const basegfx::BColor aModifiedColor(maBColorModifierStack.getModifiedColor(basegfx::BColor())); 514 basegfx::B2DPolygon aPolygon(basegfx::tools::createUnitPolygon()); 515 aPolygon.transform(aLocalTransform); 516 517 mpOutputDevice->SetFillColor(Color(aModifiedColor)); 518 mpOutputDevice->SetLineColor(); 519 mpOutputDevice->DrawPolygon(aPolygon); 520 521 bPainted = true; 522 } 523 } 524 525 if(!bPainted) 526 { 527 sal_Int32 nBLeft(basegfx::fround(aGraphicRange.getMinX())); 528 sal_Int32 nBTop(basegfx::fround(aGraphicRange.getMinY())); 529 const sal_Int32 nOLeft(basegfx::fround(aObjectRange.getMinX())); 530 const sal_Int32 nOTop(basegfx::fround(aObjectRange.getMinY())); 531 sal_Int32 nPosX(0); 532 sal_Int32 nPosY(0); 533 534 if(nBLeft > nOLeft) 535 { 536 const sal_Int32 nDiff((nBLeft / nBWidth) + 1); 537 538 nPosX -= nDiff; 539 nBLeft -= nDiff * nBWidth; 540 } 541 542 if(nBLeft + nBWidth <= nOLeft) 543 { 544 const sal_Int32 nDiff(-nBLeft / nBWidth); 545 546 nPosX += nDiff; 547 nBLeft += nDiff * nBWidth; 548 } 549 550 if(nBTop > nOTop) 551 { 552 const sal_Int32 nDiff((nBTop / nBHeight) + 1); 553 554 nPosY -= nDiff; 555 nBTop -= nDiff * nBHeight; 556 } 557 558 if(nBTop + nBHeight <= nOTop) 559 { 560 const sal_Int32 nDiff(-nBTop / nBHeight); 561 562 nPosY += nDiff; 563 nBTop += nDiff * nBHeight; 564 } 565 566 // prepare OutDev 567 const Point aEmptyPoint(0, 0); 568 const Rectangle aVisiblePixel(aEmptyPoint, mpOutputDevice->GetOutputSizePixel()); 569 const bool bWasEnabled(mpOutputDevice->IsMapModeEnabled()); 570 mpOutputDevice->EnableMapMode(false); 571 572 // check if offset is used 573 const sal_Int32 nOffsetX(basegfx::fround(rFillGraphicAttribute.getOffsetX() * nBWidth)); 574 575 if(nOffsetX) 576 { 577 // offset in X, so iterate over Y first and draw lines 578 for(sal_Int32 nYPos(nBTop); nYPos < nOTop + nOHeight; nYPos += nBHeight, nPosY++) 579 { 580 for(sal_Int32 nXPos(nPosY % 2 ? nBLeft - nBWidth + nOffsetX : nBLeft); 581 nXPos < nOLeft + nOWidth; nXPos += nBWidth) 582 { 583 const Rectangle aOutRectPixel(Point(nXPos, nYPos), aNeededBitmapSizePixel); 584 585 if(aOutRectPixel.IsOver(aVisiblePixel)) 586 { 587 if(bPreScaled) 588 { 589 mpOutputDevice->DrawBitmapEx(aOutRectPixel.TopLeft(), aBitmapEx); 590 } 591 else 592 { 593 mpOutputDevice->DrawBitmapEx(aOutRectPixel.TopLeft(), aNeededBitmapSizePixel, aBitmapEx); 594 } 595 } 596 } 597 } 598 } 599 else 600 { 601 // check if offset is used 602 const sal_Int32 nOffsetY(basegfx::fround(rFillGraphicAttribute.getOffsetY() * nBHeight)); 603 604 // possible offset in Y, so iterate over X first and draw columns 605 for(sal_Int32 nXPos(nBLeft); nXPos < nOLeft + nOWidth; nXPos += nBWidth, nPosX++) 606 { 607 for(sal_Int32 nYPos(nPosX % 2 ? nBTop - nBHeight + nOffsetY : nBTop); 608 nYPos < nOTop + nOHeight; nYPos += nBHeight) 609 { 610 const Rectangle aOutRectPixel(Point(nXPos, nYPos), aNeededBitmapSizePixel); 611 612 if(aOutRectPixel.IsOver(aVisiblePixel)) 613 { 614 if(bPreScaled) 615 { 616 mpOutputDevice->DrawBitmapEx(aOutRectPixel.TopLeft(), aBitmapEx); 617 } 618 else 619 { 620 mpOutputDevice->DrawBitmapEx(aOutRectPixel.TopLeft(), aNeededBitmapSizePixel, aBitmapEx); 621 } 622 } 623 } 624 } 625 } 626 627 // restore OutDev 628 mpOutputDevice->EnableMapMode(bWasEnabled); 629 } 630 } 631 } 632 } 633 } 634 } 635 636 if(!bPrimitiveAccepted) 637 { 638 // do not accept, use decomposition 639 process(rFillBitmapCandidate.get2DDecomposition(getViewInformation2D())); 640 } 641 } 642 643 // direct draw of Graphic RenderPolyPolygonGraphicPrimitive2D(const primitive2d::PolyPolygonGraphicPrimitive2D & rPolygonCandidate)644 void VclProcessor2D::RenderPolyPolygonGraphicPrimitive2D(const primitive2d::PolyPolygonGraphicPrimitive2D& rPolygonCandidate) 645 { 646 bool bDone(false); 647 const basegfx::B2DPolyPolygon& rPolyPolygon = rPolygonCandidate.getB2DPolyPolygon(); 648 649 // #121194# Todo: check if this works 650 if(!rPolyPolygon.count()) 651 { 652 // empty polyPolygon, done 653 bDone = true; 654 } 655 else 656 { 657 const attribute::FillGraphicAttribute& rFillGraphicAttribute = rPolygonCandidate.getFillGraphic(); 658 659 // try to catch cases where the graphic will be color-modified to a single 660 // color (e.g. shadow) 661 switch(rFillGraphicAttribute.getGraphic().GetType()) 662 { 663 case GRAPHIC_GDIMETAFILE: 664 { 665 // metafiles are potentially transparent, cannot optimize, not done 666 break; 667 } 668 case GRAPHIC_BITMAP: 669 { 670 if(!rFillGraphicAttribute.getGraphic().IsTransparent() && !rFillGraphicAttribute.getGraphic().IsAlpha()) 671 { 672 // bitmap is not transparent and has no alpha 673 const sal_uInt32 nBColorModifierStackCount(maBColorModifierStack.count()); 674 675 if(nBColorModifierStackCount) 676 { 677 const basegfx::BColorModifierSharedPtr& rTopmostModifier = maBColorModifierStack.getBColorModifier(nBColorModifierStackCount - 1); 678 const basegfx::BColorModifier_replace* pReplacer = dynamic_cast< const basegfx::BColorModifier_replace* >(rTopmostModifier.get()); 679 680 if(pReplacer) 681 { 682 // the bitmap fill is in unified color, so we can replace it with 683 // a single polygon fill. The form of the fill depends on tiling 684 if(rFillGraphicAttribute.getTiling()) 685 { 686 // with tiling, fill the whole PolyPolygon with the modifier color 687 basegfx::B2DPolyPolygon aLocalPolyPolygon(rPolyPolygon); 688 689 aLocalPolyPolygon.transform(maCurrentTransformation); 690 mpOutputDevice->SetLineColor(); 691 mpOutputDevice->SetFillColor(Color(pReplacer->getBColor())); 692 mpOutputDevice->DrawPolyPolygon(aLocalPolyPolygon); 693 } 694 else 695 { 696 // without tiling, only the area common to the bitmap tile and the 697 // PolyPolygon is filled. Create the bitmap tile area in object 698 // coordinates. For this, the object transformation needs to be created 699 // from the already scaled PolyPolygon. The tile area in object 700 // coordinates wil always be non-rotated, so it's not necessary to 701 // work with a polygon here 702 basegfx::B2DRange aTileRange(rFillGraphicAttribute.getGraphicRange()); 703 const basegfx::B2DRange aPolyPolygonRange(rPolyPolygon.getB2DRange()); 704 const basegfx::B2DHomMatrix aNewObjectTransform( 705 basegfx::tools::createScaleTranslateB2DHomMatrix( 706 aPolyPolygonRange.getRange(), 707 aPolyPolygonRange.getMinimum())); 708 709 aTileRange.transform(aNewObjectTransform); 710 711 // now clip the object polyPolygon against the tile range 712 // to get the common area 713 basegfx::B2DPolyPolygon aTarget = basegfx::tools::clipPolyPolygonOnRange( 714 rPolyPolygon, 715 aTileRange, 716 true, 717 false); 718 719 if(aTarget.count()) 720 { 721 aTarget.transform(maCurrentTransformation); 722 mpOutputDevice->SetLineColor(); 723 mpOutputDevice->SetFillColor(Color(pReplacer->getBColor())); 724 mpOutputDevice->DrawPolyPolygon(aTarget); 725 } 726 } 727 728 // simplified output executed, we are done 729 bDone = true; 730 } 731 } 732 } 733 break; 734 } 735 default: //GRAPHIC_NONE, GRAPHIC_DEFAULT 736 { 737 // empty graphic, we are done 738 bDone = true; 739 break; 740 } 741 } 742 } 743 744 if(!bDone) 745 { 746 // use default decomposition 747 process(rPolygonCandidate.get2DDecomposition(getViewInformation2D())); 748 } 749 } 750 751 // mask group. Force output to VDev and create mask from given mask RenderMaskPrimitive2DPixel(const primitive2d::MaskPrimitive2D & rMaskCandidate)752 void VclProcessor2D::RenderMaskPrimitive2DPixel(const primitive2d::MaskPrimitive2D& rMaskCandidate) 753 { 754 if(rMaskCandidate.getChildren().hasElements()) 755 { 756 basegfx::B2DPolyPolygon aMask(rMaskCandidate.getMask()); 757 758 if(aMask.count()) 759 { 760 aMask.transform(maCurrentTransformation); 761 const basegfx::B2DRange aRange(basegfx::tools::getRange(aMask)); 762 impBufferDevice aBufferDevice(*mpOutputDevice, aRange, true); 763 764 if(aBufferDevice.isVisible()) 765 { 766 // remember last OutDev and set to content 767 OutputDevice* pLastOutputDevice = mpOutputDevice; 768 mpOutputDevice = &aBufferDevice.getContent(); 769 770 // paint to it 771 process(rMaskCandidate.getChildren()); 772 773 // back to old OutDev 774 mpOutputDevice = pLastOutputDevice; 775 776 // draw mask 777 if(getOptionsDrawinglayer().IsAntiAliasing()) 778 { 779 // with AA, use 8bit AlphaMask to get nice borders 780 VirtualDevice& rTransparence = aBufferDevice.getTransparence(); 781 rTransparence.SetLineColor(); 782 rTransparence.SetFillColor(COL_BLACK); 783 rTransparence.DrawPolyPolygon(aMask); 784 785 // dump buffer to outdev 786 aBufferDevice.paint(); 787 } 788 else 789 { 790 // No AA, use 1bit mask 791 VirtualDevice& rMask = aBufferDevice.getMask(); 792 rMask.SetLineColor(); 793 rMask.SetFillColor(COL_BLACK); 794 rMask.DrawPolyPolygon(aMask); 795 796 // dump buffer to outdev 797 aBufferDevice.paint(); 798 } 799 } 800 } 801 } 802 } 803 804 // modified color group. Force output to unified color. RenderModifiedColorPrimitive2D(const primitive2d::ModifiedColorPrimitive2D & rModifiedCandidate)805 void VclProcessor2D::RenderModifiedColorPrimitive2D(const primitive2d::ModifiedColorPrimitive2D& rModifiedCandidate) 806 { 807 if(rModifiedCandidate.getChildren().hasElements()) 808 { 809 maBColorModifierStack.push(rModifiedCandidate.getColorModifier()); 810 process(rModifiedCandidate.getChildren()); 811 maBColorModifierStack.pop(); 812 } 813 } 814 815 // unified sub-transparence. Draw to VDev first. RenderUnifiedTransparencePrimitive2D(const primitive2d::UnifiedTransparencePrimitive2D & rTransCandidate)816 void VclProcessor2D::RenderUnifiedTransparencePrimitive2D(const primitive2d::UnifiedTransparencePrimitive2D& rTransCandidate) 817 { 818 static bool bForceToDecomposition(false); 819 820 if(rTransCandidate.getChildren().hasElements()) 821 { 822 if(bForceToDecomposition) 823 { 824 // use decomposition 825 process(rTransCandidate.get2DDecomposition(getViewInformation2D())); 826 } 827 else 828 { 829 if(0.0 == rTransCandidate.getTransparence()) 830 { 831 // no transparence used, so just use the content 832 process(rTransCandidate.getChildren()); 833 } 834 else if(rTransCandidate.getTransparence() > 0.0 && rTransCandidate.getTransparence() < 1.0) 835 { 836 // transparence is in visible range 837 basegfx::B2DRange aRange(primitive2d::getB2DRangeFromPrimitive2DSequence(rTransCandidate.getChildren(), getViewInformation2D())); 838 aRange.transform(maCurrentTransformation); 839 impBufferDevice aBufferDevice(*mpOutputDevice, aRange, true); 840 841 if(aBufferDevice.isVisible()) 842 { 843 // remember last OutDev and set to content 844 OutputDevice* pLastOutputDevice = mpOutputDevice; 845 mpOutputDevice = &aBufferDevice.getContent(); 846 847 // paint content to it 848 process(rTransCandidate.getChildren()); 849 850 // back to old OutDev 851 mpOutputDevice = pLastOutputDevice; 852 853 // dump buffer to outdev using given transparence 854 aBufferDevice.paint(rTransCandidate.getTransparence()); 855 } 856 } 857 } 858 } 859 } 860 861 // sub-transparence group. Draw to VDev first. RenderTransparencePrimitive2D(const primitive2d::TransparencePrimitive2D & rTransCandidate)862 void VclProcessor2D::RenderTransparencePrimitive2D(const primitive2d::TransparencePrimitive2D& rTransCandidate) 863 { 864 if(rTransCandidate.getChildren().hasElements()) 865 { 866 basegfx::B2DRange aRange(primitive2d::getB2DRangeFromPrimitive2DSequence(rTransCandidate.getChildren(), getViewInformation2D())); 867 aRange.transform(maCurrentTransformation); 868 impBufferDevice aBufferDevice(*mpOutputDevice, aRange, true); 869 870 if(aBufferDevice.isVisible()) 871 { 872 // remember last OutDev and set to content 873 OutputDevice* pLastOutputDevice = mpOutputDevice; 874 mpOutputDevice = &aBufferDevice.getContent(); 875 876 // paint content to it 877 process(rTransCandidate.getChildren()); 878 879 // set to mask 880 mpOutputDevice = &aBufferDevice.getTransparence(); 881 882 // when painting transparence masks, reset the color stack 883 basegfx::BColorModifierStack aLastBColorModifierStack(maBColorModifierStack); 884 maBColorModifierStack = basegfx::BColorModifierStack(); 885 886 // paint mask to it (always with transparence intensities, evtl. with AA) 887 process(rTransCandidate.getTransparence()); 888 889 // back to old color stack 890 maBColorModifierStack = aLastBColorModifierStack; 891 892 // back to old OutDev 893 mpOutputDevice = pLastOutputDevice; 894 895 // dump buffer to outdev 896 aBufferDevice.paint(); 897 } 898 } 899 } 900 901 // transform group. RenderTransformPrimitive2D(const primitive2d::TransformPrimitive2D & rTransformCandidate)902 void VclProcessor2D::RenderTransformPrimitive2D(const primitive2d::TransformPrimitive2D& rTransformCandidate) 903 { 904 // remember current transformation and ViewInformation 905 const basegfx::B2DHomMatrix aLastCurrentTransformation(maCurrentTransformation); 906 const geometry::ViewInformation2D aLastViewInformation2D(getViewInformation2D()); 907 908 // create new transformations for CurrentTransformation 909 // and for local ViewInformation2D 910 maCurrentTransformation = maCurrentTransformation * rTransformCandidate.getTransformation(); 911 const geometry::ViewInformation2D aViewInformation2D( 912 getViewInformation2D().getObjectTransformation() * rTransformCandidate.getTransformation(), 913 getViewInformation2D().getViewTransformation(), 914 getViewInformation2D().getViewport(), 915 getViewInformation2D().getVisualizedPage(), 916 getViewInformation2D().getViewTime(), 917 getViewInformation2D().getExtendedInformationSequence()); 918 updateViewInformation(aViewInformation2D); 919 920 // process content 921 process(rTransformCandidate.getChildren()); 922 923 // restore transformations 924 maCurrentTransformation = aLastCurrentTransformation; 925 updateViewInformation(aLastViewInformation2D); 926 } 927 928 // new XDrawPage for ViewInformation2D RenderPagePreviewPrimitive2D(const primitive2d::PagePreviewPrimitive2D & rPagePreviewCandidate)929 void VclProcessor2D::RenderPagePreviewPrimitive2D(const primitive2d::PagePreviewPrimitive2D& rPagePreviewCandidate) 930 { 931 // remember current transformation and ViewInformation 932 const geometry::ViewInformation2D aLastViewInformation2D(getViewInformation2D()); 933 934 // create new local ViewInformation2D 935 const geometry::ViewInformation2D aViewInformation2D( 936 getViewInformation2D().getObjectTransformation(), 937 getViewInformation2D().getViewTransformation(), 938 getViewInformation2D().getViewport(), 939 rPagePreviewCandidate.getXDrawPage(), 940 getViewInformation2D().getViewTime(), 941 getViewInformation2D().getExtendedInformationSequence()); 942 updateViewInformation(aViewInformation2D); 943 944 // process decomposed content 945 process(rPagePreviewCandidate.get2DDecomposition(getViewInformation2D())); 946 947 // restore transformations 948 updateViewInformation(aLastViewInformation2D); 949 } 950 951 // marker RenderMarkerArrayPrimitive2D(const primitive2d::MarkerArrayPrimitive2D & rMarkArrayCandidate)952 void VclProcessor2D::RenderMarkerArrayPrimitive2D(const primitive2d::MarkerArrayPrimitive2D& rMarkArrayCandidate) 953 { 954 static bool bCheckCompleteMarkerDecompose(false); 955 if(bCheckCompleteMarkerDecompose) 956 { 957 process(rMarkArrayCandidate.get2DDecomposition(getViewInformation2D())); 958 return; 959 } 960 961 // get data 962 const std::vector< basegfx::B2DPoint >& rPositions = rMarkArrayCandidate.getPositions(); 963 const sal_uInt32 nCount(rPositions.size()); 964 965 if(nCount && !rMarkArrayCandidate.getMarker().IsEmpty()) 966 { 967 // get pixel size 968 const BitmapEx& rMarker(rMarkArrayCandidate.getMarker()); 969 const Size aBitmapSize(rMarker.GetSizePixel()); 970 971 if(aBitmapSize.Width() && aBitmapSize.Height()) 972 { 973 // get discrete half size 974 const basegfx::B2DVector aDiscreteHalfSize( 975 (aBitmapSize.getWidth() - 1.0) * 0.5, 976 (aBitmapSize.getHeight() - 1.0) * 0.5); 977 const bool bWasEnabled(mpOutputDevice->IsMapModeEnabled()); 978 979 // do not forget evtl. moved origin in target device MapMode when 980 // switching it off; it would be missing and lead to wrong positions. 981 // All his could be done using logic sizes and coordinates, too, but 982 // we want a 1:1 bitmap rendering here, so it's more safe and faster 983 // to work with switching off MapMode usage completely. 984 const Point aOrigin(mpOutputDevice->GetMapMode().GetOrigin()); 985 986 mpOutputDevice->EnableMapMode(false); 987 988 for(std::vector< basegfx::B2DPoint >::const_iterator aIter(rPositions.begin()); aIter != rPositions.end(); aIter++) 989 { 990 const basegfx::B2DPoint aDiscreteTopLeft((maCurrentTransformation * (*aIter)) - aDiscreteHalfSize); 991 const Point aDiscretePoint(basegfx::fround(aDiscreteTopLeft.getX()), basegfx::fround(aDiscreteTopLeft.getY())); 992 993 mpOutputDevice->DrawBitmapEx(aDiscretePoint + aOrigin, rMarker); 994 } 995 996 mpOutputDevice->EnableMapMode(bWasEnabled); 997 } 998 } 999 } 1000 1001 // point RenderPointArrayPrimitive2D(const primitive2d::PointArrayPrimitive2D & rPointArrayCandidate)1002 void VclProcessor2D::RenderPointArrayPrimitive2D(const primitive2d::PointArrayPrimitive2D& rPointArrayCandidate) 1003 { 1004 const std::vector< basegfx::B2DPoint >& rPositions = rPointArrayCandidate.getPositions(); 1005 const basegfx::BColor aRGBColor(maBColorModifierStack.getModifiedColor(rPointArrayCandidate.getRGBColor())); 1006 const Color aVCLColor(aRGBColor); 1007 1008 for(std::vector< basegfx::B2DPoint >::const_iterator aIter(rPositions.begin()); aIter != rPositions.end(); aIter++) 1009 { 1010 const basegfx::B2DPoint aViewPosition(maCurrentTransformation * (*aIter)); 1011 const Point aPos(basegfx::fround(aViewPosition.getX()), basegfx::fround(aViewPosition.getY())); 1012 1013 mpOutputDevice->DrawPixel(aPos, aVCLColor); 1014 } 1015 } 1016 RenderPolygonStrokePrimitive2D(const primitive2d::PolygonStrokePrimitive2D & rPolygonStrokeCandidate)1017 void VclProcessor2D::RenderPolygonStrokePrimitive2D(const primitive2d::PolygonStrokePrimitive2D& rPolygonStrokeCandidate) 1018 { 1019 // #i101491# method restructured to clearly use the DrawPolyLine 1020 // calls starting from a deined line width 1021 const attribute::LineAttribute& rLineAttribute = rPolygonStrokeCandidate.getLineAttribute(); 1022 const double fLineWidth(rLineAttribute.getWidth()); 1023 bool bDone(false); 1024 1025 if(basegfx::fTools::more(fLineWidth, 0.0)) 1026 { 1027 const basegfx::B2DVector aDiscreteUnit(maCurrentTransformation * basegfx::B2DVector(fLineWidth, 0.0)); 1028 const double fDiscreteLineWidth(aDiscreteUnit.getLength()); 1029 const attribute::StrokeAttribute& rStrokeAttribute = rPolygonStrokeCandidate.getStrokeAttribute(); 1030 const basegfx::BColor aHairlineColor(maBColorModifierStack.getModifiedColor(rLineAttribute.getColor())); 1031 basegfx::B2DPolyPolygon aHairlinePolyPolygon; 1032 1033 mpOutputDevice->SetLineColor(Color(aHairlineColor)); 1034 mpOutputDevice->SetFillColor(); 1035 1036 if(0.0 == rStrokeAttribute.getFullDotDashLen()) 1037 { 1038 // no line dashing, just copy 1039 aHairlinePolyPolygon.append(rPolygonStrokeCandidate.getB2DPolygon()); 1040 } 1041 else 1042 { 1043 // else apply LineStyle 1044 basegfx::tools::applyLineDashing(rPolygonStrokeCandidate.getB2DPolygon(), 1045 rStrokeAttribute.getDotDashArray(), 1046 &aHairlinePolyPolygon, 0, rStrokeAttribute.getFullDotDashLen()); 1047 } 1048 1049 const sal_uInt32 nCount(aHairlinePolyPolygon.count()); 1050 1051 if(nCount) 1052 { 1053 const bool bAntiAliased(getOptionsDrawinglayer().IsAntiAliasing()); 1054 aHairlinePolyPolygon.transform(maCurrentTransformation); 1055 1056 if(bAntiAliased) 1057 { 1058 if(basegfx::fTools::lessOrEqual(fDiscreteLineWidth, 1.0)) 1059 { 1060 // line in range ]0.0 .. 1.0[ 1061 // paint as simple hairline 1062 for(sal_uInt32 a(0); a < nCount; a++) 1063 { 1064 mpOutputDevice->DrawPolyLine(aHairlinePolyPolygon.getB2DPolygon(a), 0.0); 1065 } 1066 1067 bDone = true; 1068 } 1069 else if(basegfx::fTools::lessOrEqual(fDiscreteLineWidth, 2.0)) 1070 { 1071 // line in range [1.0 .. 2.0[ 1072 // paint as 2x2 with dynamic line distance 1073 basegfx::B2DHomMatrix aMat; 1074 const double fDistance(fDiscreteLineWidth - 1.0); 1075 const double fHalfDistance(fDistance * 0.5); 1076 1077 for(sal_uInt32 a(0); a < nCount; a++) 1078 { 1079 basegfx::B2DPolygon aCandidate(aHairlinePolyPolygon.getB2DPolygon(a)); 1080 1081 aMat.set(0, 2, -fHalfDistance); 1082 aMat.set(1, 2, -fHalfDistance); 1083 aCandidate.transform(aMat); 1084 mpOutputDevice->DrawPolyLine(aCandidate, 0.0); 1085 1086 aMat.set(0, 2, fDistance); 1087 aMat.set(1, 2, 0.0); 1088 aCandidate.transform(aMat); 1089 mpOutputDevice->DrawPolyLine(aCandidate, 0.0); 1090 1091 aMat.set(0, 2, 0.0); 1092 aMat.set(1, 2, fDistance); 1093 aCandidate.transform(aMat); 1094 mpOutputDevice->DrawPolyLine(aCandidate, 0.0); 1095 1096 aMat.set(0, 2, -fDistance); 1097 aMat.set(1, 2, 0.0); 1098 aCandidate.transform(aMat); 1099 mpOutputDevice->DrawPolyLine(aCandidate, 0.0); 1100 } 1101 1102 bDone = true; 1103 } 1104 else if(basegfx::fTools::lessOrEqual(fDiscreteLineWidth, 3.0)) 1105 { 1106 // line in range [2.0 .. 3.0] 1107 // paint as cross in a 3x3 with dynamic line distance 1108 basegfx::B2DHomMatrix aMat; 1109 const double fDistance((fDiscreteLineWidth - 1.0) * 0.5); 1110 1111 for(sal_uInt32 a(0); a < nCount; a++) 1112 { 1113 basegfx::B2DPolygon aCandidate(aHairlinePolyPolygon.getB2DPolygon(a)); 1114 1115 mpOutputDevice->DrawPolyLine(aCandidate, 0.0); 1116 1117 aMat.set(0, 2, -fDistance); 1118 aMat.set(1, 2, 0.0); 1119 aCandidate.transform(aMat); 1120 mpOutputDevice->DrawPolyLine(aCandidate, 0.0); 1121 1122 aMat.set(0, 2, fDistance); 1123 aMat.set(1, 2, -fDistance); 1124 aCandidate.transform(aMat); 1125 mpOutputDevice->DrawPolyLine(aCandidate, 0.0); 1126 1127 aMat.set(0, 2, fDistance); 1128 aMat.set(1, 2, fDistance); 1129 aCandidate.transform(aMat); 1130 mpOutputDevice->DrawPolyLine(aCandidate, 0.0); 1131 1132 aMat.set(0, 2, -fDistance); 1133 aMat.set(1, 2, fDistance); 1134 aCandidate.transform(aMat); 1135 mpOutputDevice->DrawPolyLine(aCandidate, 0.0); 1136 } 1137 1138 bDone = true; 1139 } 1140 else 1141 { 1142 // #i101491# line width above 3.0 1143 } 1144 } 1145 else 1146 { 1147 if(basegfx::fTools::lessOrEqual(fDiscreteLineWidth, 1.5)) 1148 { 1149 // line width below 1.5, draw the basic hairline polygon 1150 for(sal_uInt32 a(0); a < nCount; a++) 1151 { 1152 mpOutputDevice->DrawPolyLine(aHairlinePolyPolygon.getB2DPolygon(a), 0.0); 1153 } 1154 1155 bDone = true; 1156 } 1157 else if(basegfx::fTools::lessOrEqual(fDiscreteLineWidth, 2.5)) 1158 { 1159 // line width is in range ]1.5 .. 2.5], use four hairlines 1160 // drawn in a square 1161 for(sal_uInt32 a(0); a < nCount; a++) 1162 { 1163 basegfx::B2DPolygon aCandidate(aHairlinePolyPolygon.getB2DPolygon(a)); 1164 basegfx::B2DHomMatrix aMat; 1165 1166 mpOutputDevice->DrawPolyLine(aCandidate, 0.0); 1167 1168 aMat.set(0, 2, 1.0); 1169 aMat.set(1, 2, 0.0); 1170 aCandidate.transform(aMat); 1171 1172 mpOutputDevice->DrawPolyLine(aCandidate, 0.0); 1173 1174 aMat.set(0, 2, 0.0); 1175 aMat.set(1, 2, 1.0); 1176 aCandidate.transform(aMat); 1177 1178 mpOutputDevice->DrawPolyLine(aCandidate, 0.0); 1179 1180 aMat.set(0, 2, -1.0); 1181 aMat.set(1, 2, 0.0); 1182 aCandidate.transform(aMat); 1183 1184 mpOutputDevice->DrawPolyLine(aCandidate, 0.0); 1185 } 1186 1187 bDone = true; 1188 } 1189 else 1190 { 1191 // #i101491# line width is above 2.5 1192 } 1193 } 1194 1195 if(!bDone && rPolygonStrokeCandidate.getB2DPolygon().count() > 1000) 1196 { 1197 // #i101491# If the polygon complexity uses more than a given amount, do 1198 // use OuputDevice::DrawPolyLine directly; this will avoid buffering all 1199 // decompositions in primtives (memory) and fallback to old line painting 1200 // for very complex polygons, too 1201 for(sal_uInt32 a(0); a < nCount; a++) 1202 { 1203 mpOutputDevice->DrawPolyLine( 1204 aHairlinePolyPolygon.getB2DPolygon(a), 1205 fDiscreteLineWidth, 1206 rLineAttribute.getLineJoin(), 1207 rLineAttribute.getLineCap()); 1208 } 1209 1210 bDone = true; 1211 } 1212 } 1213 } 1214 1215 if(!bDone) 1216 { 1217 // remember that we enter a PolygonStrokePrimitive2D decomposition, 1218 // used for AA thick line drawing 1219 mnPolygonStrokePrimitive2D++; 1220 1221 // line width is big enough for standard filled polygon visualisation or zero 1222 process(rPolygonStrokeCandidate.get2DDecomposition(getViewInformation2D())); 1223 1224 // leave PolygonStrokePrimitive2D 1225 mnPolygonStrokePrimitive2D--; 1226 } 1227 } 1228 RenderEpsPrimitive2D(const primitive2d::EpsPrimitive2D & rEpsPrimitive2D)1229 void VclProcessor2D::RenderEpsPrimitive2D(const primitive2d::EpsPrimitive2D& rEpsPrimitive2D) 1230 { 1231 // The new decomposition of Metafiles made it necessary to add an Eps 1232 // primitive to handle embedded Eps data. On some devices, this can be 1233 // painted directly (mac, printer). 1234 // To be able to handle the replacement correctly, i need to handle it myself 1235 // since DrawEPS will not be able e.g. to rotate the replacement. To be able 1236 // to do that, i added a boolean return to OutputDevice::DrawEPS(..) 1237 // to know when EPS was handled directly already. 1238 basegfx::B2DRange aRange(0.0, 0.0, 1.0, 1.0); 1239 aRange.transform(maCurrentTransformation * rEpsPrimitive2D.getEpsTransform()); 1240 1241 if(!aRange.isEmpty()) 1242 { 1243 const Rectangle aRectangle( 1244 (sal_Int32)floor(aRange.getMinX()), (sal_Int32)floor(aRange.getMinY()), 1245 (sal_Int32)ceil(aRange.getMaxX()), (sal_Int32)ceil(aRange.getMaxY())); 1246 1247 if(!aRectangle.IsEmpty()) 1248 { 1249 // try to paint EPS directly without fallback visualisation 1250 const bool bEPSPaintedDirectly(mpOutputDevice->DrawEPS( 1251 aRectangle.TopLeft(), 1252 aRectangle.GetSize(), 1253 rEpsPrimitive2D.getGfxLink(), 1254 0)); 1255 1256 if(!bEPSPaintedDirectly) 1257 { 1258 // use the decomposition which will correctly handle the 1259 // fallback visualisation using full transformation (e.g. rotation) 1260 process(rEpsPrimitive2D.get2DDecomposition(getViewInformation2D())); 1261 } 1262 } 1263 } 1264 } 1265 RenderSvgLinearAtomPrimitive2D(const primitive2d::SvgLinearAtomPrimitive2D & rCandidate)1266 void VclProcessor2D::RenderSvgLinearAtomPrimitive2D(const primitive2d::SvgLinearAtomPrimitive2D& rCandidate) 1267 { 1268 const double fDelta(rCandidate.getOffsetB() - rCandidate.getOffsetA()); 1269 1270 if(basegfx::fTools::more(fDelta, 0.0)) 1271 { 1272 const basegfx::BColor aColorA(maBColorModifierStack.getModifiedColor(rCandidate.getColorA())); 1273 const basegfx::BColor aColorB(maBColorModifierStack.getModifiedColor(rCandidate.getColorB())); 1274 1275 // calculate discrete unit in WorldCoordinates; use diagonal (1.0, 1.0) and divide by sqrt(2) 1276 const basegfx::B2DVector aDiscreteVector(getViewInformation2D().getInverseObjectToViewTransformation() * basegfx::B2DVector(1.0, 1.0)); 1277 const double fDiscreteUnit(aDiscreteVector.getLength() * (1.0 / 1.414213562373)); 1278 1279 // use color distance and discrete lengths to calculate step count 1280 const sal_uInt32 nSteps(calculateStepsForSvgGradient(aColorA, aColorB, fDelta, fDiscreteUnit)); 1281 1282 // switch off line painting 1283 mpOutputDevice->SetLineColor(); 1284 1285 // prepare polygon in needed width at start position (with discrete overlap) 1286 const basegfx::B2DPolygon aPolygon( 1287 basegfx::tools::createPolygonFromRect( 1288 basegfx::B2DRange( 1289 rCandidate.getOffsetA() - fDiscreteUnit, 1290 0.0, 1291 rCandidate.getOffsetA() + (fDelta / nSteps) + fDiscreteUnit, 1292 1.0))); 1293 1294 1295 // prepare loop ([0.0 .. 1.0[) 1296 double fUnitScale(0.0); 1297 const double fUnitStep(1.0 / nSteps); 1298 1299 // loop and paint 1300 for(sal_uInt32 a(0); a < nSteps; a++, fUnitScale += fUnitStep) 1301 { 1302 basegfx::B2DPolygon aNew(aPolygon); 1303 1304 aNew.transform(maCurrentTransformation * basegfx::tools::createTranslateB2DHomMatrix(fDelta * fUnitScale, 0.0)); 1305 mpOutputDevice->SetFillColor(Color(basegfx::interpolate(aColorA, aColorB, fUnitScale))); 1306 mpOutputDevice->DrawPolyPolygon(basegfx::B2DPolyPolygon(aNew)); 1307 } 1308 } 1309 } 1310 RenderSvgRadialAtomPrimitive2D(const primitive2d::SvgRadialAtomPrimitive2D & rCandidate)1311 void VclProcessor2D::RenderSvgRadialAtomPrimitive2D(const primitive2d::SvgRadialAtomPrimitive2D& rCandidate) 1312 { 1313 const double fDeltaScale(rCandidate.getScaleB() - rCandidate.getScaleA()); 1314 1315 if(basegfx::fTools::more(fDeltaScale, 0.0)) 1316 { 1317 const basegfx::BColor aColorA(maBColorModifierStack.getModifiedColor(rCandidate.getColorA())); 1318 const basegfx::BColor aColorB(maBColorModifierStack.getModifiedColor(rCandidate.getColorB())); 1319 1320 // calculate discrete unit in WorldCoordinates; use diagonal (1.0, 1.0) and divide by sqrt(2) 1321 const basegfx::B2DVector aDiscreteVector(getViewInformation2D().getInverseObjectToViewTransformation() * basegfx::B2DVector(1.0, 1.0)); 1322 const double fDiscreteUnit(aDiscreteVector.getLength() * (1.0 / 1.414213562373)); 1323 1324 // use color distance and discrete lengths to calculate step count 1325 const sal_uInt32 nSteps(calculateStepsForSvgGradient(aColorA, aColorB, fDeltaScale, fDiscreteUnit)); 1326 1327 // switch off line painting 1328 mpOutputDevice->SetLineColor(); 1329 1330 // prepare loop ([0.0 .. 1.0[, full polygons, no polypolygons with holes) 1331 double fUnitScale(0.0); 1332 const double fUnitStep(1.0 / nSteps); 1333 1334 for(sal_uInt32 a(0); a < nSteps; a++, fUnitScale += fUnitStep) 1335 { 1336 basegfx::B2DHomMatrix aTransform; 1337 const double fEndScale(rCandidate.getScaleB() - (fDeltaScale * fUnitScale)); 1338 1339 if(rCandidate.isTranslateSet()) 1340 { 1341 const basegfx::B2DVector aTranslate( 1342 basegfx::interpolate( 1343 rCandidate.getTranslateB(), 1344 rCandidate.getTranslateA(), 1345 fUnitScale)); 1346 1347 aTransform = basegfx::tools::createScaleTranslateB2DHomMatrix( 1348 fEndScale, 1349 fEndScale, 1350 aTranslate.getX(), 1351 aTranslate.getY()); 1352 } 1353 else 1354 { 1355 aTransform = basegfx::tools::createScaleB2DHomMatrix( 1356 fEndScale, 1357 fEndScale); 1358 } 1359 1360 basegfx::B2DPolygon aNew(basegfx::tools::createPolygonFromUnitCircle()); 1361 1362 aNew.transform(maCurrentTransformation * aTransform); 1363 mpOutputDevice->SetFillColor(Color(basegfx::interpolate(aColorB, aColorA, fUnitScale))); 1364 mpOutputDevice->DrawPolyPolygon(basegfx::B2DPolyPolygon(aNew)); 1365 } 1366 } 1367 } 1368 adaptLineToFillDrawMode() const1369 void VclProcessor2D::adaptLineToFillDrawMode() const 1370 { 1371 const sal_uInt32 nOriginalDrawMode(mpOutputDevice->GetDrawMode()); 1372 1373 if(nOriginalDrawMode & (DRAWMODE_BLACKLINE|DRAWMODE_GRAYLINE|DRAWMODE_GHOSTEDLINE|DRAWMODE_WHITELINE|DRAWMODE_SETTINGSLINE)) 1374 { 1375 sal_uInt32 nAdaptedDrawMode(nOriginalDrawMode); 1376 1377 if(nOriginalDrawMode & DRAWMODE_BLACKLINE) 1378 { 1379 nAdaptedDrawMode |= DRAWMODE_BLACKFILL; 1380 } 1381 else 1382 { 1383 nAdaptedDrawMode &= ~DRAWMODE_BLACKFILL; 1384 } 1385 1386 if(nOriginalDrawMode & DRAWMODE_GRAYLINE) 1387 { 1388 nAdaptedDrawMode |= DRAWMODE_GRAYFILL; 1389 } 1390 else 1391 { 1392 nAdaptedDrawMode &= ~DRAWMODE_GRAYFILL; 1393 } 1394 1395 if(nOriginalDrawMode & DRAWMODE_GHOSTEDLINE) 1396 { 1397 nAdaptedDrawMode |= DRAWMODE_GHOSTEDFILL; 1398 } 1399 else 1400 { 1401 nAdaptedDrawMode &= ~DRAWMODE_GHOSTEDFILL; 1402 } 1403 1404 if(nOriginalDrawMode & DRAWMODE_WHITELINE) 1405 { 1406 nAdaptedDrawMode |= DRAWMODE_WHITEFILL; 1407 } 1408 else 1409 { 1410 nAdaptedDrawMode &= ~DRAWMODE_WHITEFILL; 1411 } 1412 1413 if(nOriginalDrawMode & DRAWMODE_SETTINGSLINE) 1414 { 1415 nAdaptedDrawMode |= DRAWMODE_SETTINGSFILL; 1416 } 1417 else 1418 { 1419 nAdaptedDrawMode &= ~DRAWMODE_SETTINGSFILL; 1420 } 1421 1422 mpOutputDevice->SetDrawMode(nAdaptedDrawMode); 1423 } 1424 } 1425 adaptTextToFillDrawMode() const1426 void VclProcessor2D::adaptTextToFillDrawMode() const 1427 { 1428 const sal_uInt32 nOriginalDrawMode(mpOutputDevice->GetDrawMode()); 1429 if(nOriginalDrawMode & (DRAWMODE_BLACKTEXT|DRAWMODE_GRAYTEXT|DRAWMODE_GHOSTEDTEXT|DRAWMODE_WHITETEXT|DRAWMODE_SETTINGSTEXT)) 1430 { 1431 sal_uInt32 nAdaptedDrawMode(nOriginalDrawMode); 1432 1433 if(nOriginalDrawMode & DRAWMODE_BLACKTEXT) 1434 { 1435 nAdaptedDrawMode |= DRAWMODE_BLACKFILL; 1436 } 1437 else 1438 { 1439 nAdaptedDrawMode &= ~DRAWMODE_BLACKFILL; 1440 } 1441 1442 if(nOriginalDrawMode & DRAWMODE_GRAYTEXT) 1443 { 1444 nAdaptedDrawMode |= DRAWMODE_GRAYFILL; 1445 } 1446 else 1447 { 1448 nAdaptedDrawMode &= ~DRAWMODE_GRAYFILL; 1449 } 1450 1451 if(nOriginalDrawMode & DRAWMODE_GHOSTEDTEXT) 1452 { 1453 nAdaptedDrawMode |= DRAWMODE_GHOSTEDFILL; 1454 } 1455 else 1456 { 1457 nAdaptedDrawMode &= ~DRAWMODE_GHOSTEDFILL; 1458 } 1459 1460 if(nOriginalDrawMode & DRAWMODE_WHITETEXT) 1461 { 1462 nAdaptedDrawMode |= DRAWMODE_WHITEFILL; 1463 } 1464 else 1465 { 1466 nAdaptedDrawMode &= ~DRAWMODE_WHITEFILL; 1467 } 1468 1469 if(nOriginalDrawMode & DRAWMODE_SETTINGSTEXT) 1470 { 1471 nAdaptedDrawMode |= DRAWMODE_SETTINGSFILL; 1472 } 1473 else 1474 { 1475 nAdaptedDrawMode &= ~DRAWMODE_SETTINGSFILL; 1476 } 1477 1478 mpOutputDevice->SetDrawMode(nAdaptedDrawMode); 1479 } 1480 } 1481 1482 ////////////////////////////////////////////////////////////////////////////// 1483 // process support 1484 VclProcessor2D(const geometry::ViewInformation2D & rViewInformation,OutputDevice & rOutDev)1485 VclProcessor2D::VclProcessor2D( 1486 const geometry::ViewInformation2D& rViewInformation, 1487 OutputDevice& rOutDev) 1488 : BaseProcessor2D(rViewInformation), 1489 mpOutputDevice(&rOutDev), 1490 maBColorModifierStack(), 1491 maCurrentTransformation(), 1492 maDrawinglayerOpt(), 1493 mnPolygonStrokePrimitive2D(0) 1494 { 1495 // set digit language, derived from SvtCTLOptions to have the correct 1496 // number display for arabic/hindi numerals 1497 const SvtCTLOptions aSvtCTLOptions; 1498 LanguageType eLang(LANGUAGE_SYSTEM); 1499 1500 if(SvtCTLOptions::NUMERALS_HINDI == aSvtCTLOptions.GetCTLTextNumerals()) 1501 { 1502 eLang = LANGUAGE_ARABIC_SAUDI_ARABIA; 1503 } 1504 else if(SvtCTLOptions::NUMERALS_ARABIC == aSvtCTLOptions.GetCTLTextNumerals()) 1505 { 1506 eLang = LANGUAGE_ENGLISH; 1507 } 1508 else 1509 { 1510 eLang = (LanguageType)Application::GetSettings().GetLanguage(); 1511 } 1512 1513 rOutDev.SetDigitLanguage(eLang); 1514 } 1515 ~VclProcessor2D()1516 VclProcessor2D::~VclProcessor2D() 1517 { 1518 } 1519 } // end of namespace processor2d 1520 } // end of namespace drawinglayer 1521 1522 ////////////////////////////////////////////////////////////////////////////// 1523 // eof 1524