LCOV - code coverage report
Current view: top level - drawinglayer/source/processor2d - vclprocessor2d.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 398 674 59.1 %
Date: 2015-06-13 12:38:46 Functions: 19 25 76.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.11