1464702f4SAndrew Rist /************************************************************** 2464702f4SAndrew Rist * 3464702f4SAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one 4464702f4SAndrew Rist * or more contributor license agreements. See the NOTICE file 5464702f4SAndrew Rist * distributed with this work for additional information 6464702f4SAndrew Rist * regarding copyright ownership. The ASF licenses this file 7464702f4SAndrew Rist * to you under the Apache License, Version 2.0 (the 8464702f4SAndrew Rist * "License"); you may not use this file except in compliance 9464702f4SAndrew Rist * with the License. You may obtain a copy of the License at 10464702f4SAndrew Rist * 11464702f4SAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0 12464702f4SAndrew Rist * 13464702f4SAndrew Rist * Unless required by applicable law or agreed to in writing, 14464702f4SAndrew Rist * software distributed under the License is distributed on an 15464702f4SAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16464702f4SAndrew Rist * KIND, either express or implied. See the License for the 17464702f4SAndrew Rist * specific language governing permissions and limitations 18464702f4SAndrew Rist * under the License. 19464702f4SAndrew Rist * 20464702f4SAndrew Rist *************************************************************/ 21464702f4SAndrew Rist 22464702f4SAndrew Rist 23cdf0e10cSrcweir 24cdf0e10cSrcweir // MARKER(update_precomp.py): autogen include statement, do not remove 25cdf0e10cSrcweir #include "precompiled_drawinglayer.hxx" 26cdf0e10cSrcweir 27cdf0e10cSrcweir #include <drawinglayer/processor2d/vclprocessor2d.hxx> 28cdf0e10cSrcweir #include <drawinglayer/primitive2d/textprimitive2d.hxx> 29cdf0e10cSrcweir #include <drawinglayer/primitive2d/textdecoratedprimitive2d.hxx> 30cdf0e10cSrcweir #include <tools/debug.hxx> 31cdf0e10cSrcweir #include <vcl/outdev.hxx> 32cdf0e10cSrcweir #include <drawinglayer/primitive2d/polygonprimitive2d.hxx> 33cdf0e10cSrcweir #include <drawinglayer/primitive2d/bitmapprimitive2d.hxx> 34cdf0e10cSrcweir #include <basegfx/polygon/b2dpolygontools.hxx> 35035a2f44SArmin Le Grand #include <drawinglayer/attribute/sdrfillgraphicattribute.hxx> 36035a2f44SArmin Le Grand #include <drawinglayer/primitive2d/fillgraphicprimitive2d.hxx> 37cdf0e10cSrcweir #include <drawinglayer/primitive2d/polypolygonprimitive2d.hxx> 38cdf0e10cSrcweir #include <drawinglayer/primitive2d/metafileprimitive2d.hxx> 39cdf0e10cSrcweir #include <drawinglayer/primitive2d/maskprimitive2d.hxx> 40cdf0e10cSrcweir #include <basegfx/polygon/b2dpolypolygontools.hxx> 41cdf0e10cSrcweir #include <vclhelperbufferdevice.hxx> 42cdf0e10cSrcweir #include <drawinglayer/primitive2d/modifiedcolorprimitive2d.hxx> 43cdf0e10cSrcweir #include <drawinglayer/primitive2d/unifiedtransparenceprimitive2d.hxx> 44cdf0e10cSrcweir #include <drawinglayer/primitive2d/transparenceprimitive2d.hxx> 45cdf0e10cSrcweir #include <drawinglayer/primitive2d/transformprimitive2d.hxx> 46cdf0e10cSrcweir #include <drawinglayer/primitive2d/markerarrayprimitive2d.hxx> 47cdf0e10cSrcweir #include <drawinglayer/primitive2d/pointarrayprimitive2d.hxx> 48cdf0e10cSrcweir #include <drawinglayer/primitive2d/wrongspellprimitive2d.hxx> 49cdf0e10cSrcweir #include <svl/ctloptions.hxx> 50cdf0e10cSrcweir #include <vcl/svapp.hxx> 51cdf0e10cSrcweir #include <drawinglayer/primitive2d/pagepreviewprimitive2d.hxx> 52cdf0e10cSrcweir #include <tools/diagnose_ex.h> 53cdf0e10cSrcweir #include <vcl/metric.hxx> 54cdf0e10cSrcweir #include <drawinglayer/primitive2d/textenumsprimitive2d.hxx> 55cdf0e10cSrcweir #include <drawinglayer/primitive2d/epsprimitive2d.hxx> 5639551d71SArmin Le Grand #include <drawinglayer/primitive2d/svggradientprimitive2d.hxx> 5739551d71SArmin Le Grand #include <basegfx/color/bcolor.hxx> 5839551d71SArmin Le Grand #include <basegfx/matrix/b2dhommatrixtools.hxx> 59035a2f44SArmin Le Grand #include <vcl/graph.hxx> 60cdf0e10cSrcweir 61cdf0e10cSrcweir ////////////////////////////////////////////////////////////////////////////// 62cdf0e10cSrcweir // control support 63cdf0e10cSrcweir 64cdf0e10cSrcweir #include <com/sun/star/awt/XWindow2.hpp> 65cdf0e10cSrcweir #include <com/sun/star/awt/PosSize.hpp> 66cdf0e10cSrcweir #include <com/sun/star/awt/XView.hpp> 67cdf0e10cSrcweir #include <drawinglayer/primitive2d/controlprimitive2d.hxx> 68cdf0e10cSrcweir #include <drawinglayer/primitive2d/textlayoutdevice.hxx> 69cdf0e10cSrcweir 70cdf0e10cSrcweir ////////////////////////////////////////////////////////////////////////////// 71cdf0e10cSrcweir // for test, can be removed again 72cdf0e10cSrcweir 73cdf0e10cSrcweir #include <basegfx/polygon/b2dpolygonclipper.hxx> 74cdf0e10cSrcweir #include <basegfx/polygon/b2dtrapezoid.hxx> 75cdf0e10cSrcweir 76cdf0e10cSrcweir ////////////////////////////////////////////////////////////////////////////// 77cdf0e10cSrcweir 78cdf0e10cSrcweir using namespace com::sun::star; 79cdf0e10cSrcweir 80cdf0e10cSrcweir ////////////////////////////////////////////////////////////////////////////// 81cdf0e10cSrcweir 8239551d71SArmin Le Grand namespace 8339551d71SArmin Le Grand { calculateStepsForSvgGradient(const basegfx::BColor & rColorA,const basegfx::BColor & rColorB,double fDelta,double fDiscreteUnit)8439551d71SArmin Le Grand sal_uInt32 calculateStepsForSvgGradient(const basegfx::BColor& rColorA, const basegfx::BColor& rColorB, double fDelta, double fDiscreteUnit) 8539551d71SArmin Le Grand { 8639551d71SArmin Le Grand // use color distance, assume to do every color step 8739551d71SArmin Le Grand sal_uInt32 nSteps(basegfx::fround(rColorA.getDistance(rColorB) * 255.0)); 8839551d71SArmin Le Grand 8939551d71SArmin Le Grand if(nSteps) 9039551d71SArmin Le Grand { 9139551d71SArmin Le Grand // calc discrete length to change color each disctete unit (pixel) 9239551d71SArmin Le Grand const sal_uInt32 nDistSteps(basegfx::fround(fDelta / fDiscreteUnit)); 9339551d71SArmin Le Grand 9439551d71SArmin Le Grand nSteps = std::min(nSteps, nDistSteps); 9539551d71SArmin Le Grand } 9639551d71SArmin Le Grand 9739551d71SArmin Le Grand // reduce quality to 3 discrete units or every 3rd color step for rendering 9839551d71SArmin Le Grand nSteps /= 2; 9939551d71SArmin Le Grand 10039551d71SArmin Le Grand // roughly cut when too big or too small (not full quality, reduce complexity) 10139551d71SArmin Le Grand nSteps = std::min(nSteps, sal_uInt32(255)); 10239551d71SArmin Le Grand nSteps = std::max(nSteps, sal_uInt32(1)); 10339551d71SArmin Le Grand 10439551d71SArmin Le Grand return nSteps; 10539551d71SArmin Le Grand } 10639551d71SArmin Le Grand } // end of anonymous namespace 10739551d71SArmin Le Grand 10839551d71SArmin Le Grand ////////////////////////////////////////////////////////////////////////////// 10939551d71SArmin Le Grand 110cdf0e10cSrcweir namespace drawinglayer 111cdf0e10cSrcweir { 112cdf0e10cSrcweir namespace processor2d 113cdf0e10cSrcweir { 114cdf0e10cSrcweir ////////////////////////////////////////////////////////////////////////////// 115cdf0e10cSrcweir // UNO class usages 116cdf0e10cSrcweir using ::com::sun::star::uno::Reference; 117cdf0e10cSrcweir using ::com::sun::star::uno::UNO_QUERY; 118cdf0e10cSrcweir using ::com::sun::star::uno::UNO_QUERY_THROW; 119cdf0e10cSrcweir using ::com::sun::star::uno::Exception; 120cdf0e10cSrcweir using ::com::sun::star::awt::XView; 121cdf0e10cSrcweir using ::com::sun::star::awt::XGraphics; 122cdf0e10cSrcweir using ::com::sun::star::awt::XWindow; 123cdf0e10cSrcweir using ::com::sun::star::awt::PosSize::POSSIZE; 124cdf0e10cSrcweir 125cdf0e10cSrcweir ////////////////////////////////////////////////////////////////////////////// 126cdf0e10cSrcweir // rendering support 127cdf0e10cSrcweir 128cdf0e10cSrcweir // directdraw of text simple portion or decorated portion primitive. When decorated, all the extra 129cdf0e10cSrcweir // information is translated to VCL parameters and set at the font. 130cdf0e10cSrcweir // Acceptance is restricted to no shearing and positive scaling in X and Y (no font mirroring 131cdf0e10cSrcweir // for VCL) RenderTextSimpleOrDecoratedPortionPrimitive2D(const primitive2d::TextSimplePortionPrimitive2D & rTextCandidate)132cdf0e10cSrcweir void VclProcessor2D::RenderTextSimpleOrDecoratedPortionPrimitive2D(const primitive2d::TextSimplePortionPrimitive2D& rTextCandidate) 133cdf0e10cSrcweir { 134cdf0e10cSrcweir // decompose matrix to have position and size of text 135cdf0e10cSrcweir basegfx::B2DHomMatrix aLocalTransform(maCurrentTransformation * rTextCandidate.getTextTransform()); 136cdf0e10cSrcweir basegfx::B2DVector aFontScaling, aTranslate; 137cdf0e10cSrcweir double fRotate, fShearX; 138cdf0e10cSrcweir aLocalTransform.decompose(aFontScaling, aTranslate, fRotate, fShearX); 139cdf0e10cSrcweir bool bPrimitiveAccepted(false); 140cdf0e10cSrcweir 141cdf0e10cSrcweir if(basegfx::fTools::equalZero(fShearX)) 142cdf0e10cSrcweir { 143cdf0e10cSrcweir if(basegfx::fTools::less(aFontScaling.getX(), 0.0) && basegfx::fTools::less(aFontScaling.getY(), 0.0)) 144cdf0e10cSrcweir { 145cdf0e10cSrcweir // handle special case: If scale is negative in (x,y) (3rd quadrant), it can 146cdf0e10cSrcweir // be expressed as rotation by PI. Use this since the Font rendering will not 147cdf0e10cSrcweir // apply the negative scales in any form 148cdf0e10cSrcweir aFontScaling = basegfx::absolute(aFontScaling); 149cdf0e10cSrcweir fRotate += F_PI; 150cdf0e10cSrcweir } 151cdf0e10cSrcweir 152cdf0e10cSrcweir if(basegfx::fTools::more(aFontScaling.getX(), 0.0) && basegfx::fTools::more(aFontScaling.getY(), 0.0)) 153cdf0e10cSrcweir { 154cdf0e10cSrcweir // Get the VCL font (use FontHeight as FontWidth) 155cdf0e10cSrcweir Font aFont(primitive2d::getVclFontFromFontAttribute( 156cdf0e10cSrcweir rTextCandidate.getFontAttribute(), 157cdf0e10cSrcweir aFontScaling.getX(), 158cdf0e10cSrcweir aFontScaling.getY(), 159cdf0e10cSrcweir fRotate, 160cdf0e10cSrcweir rTextCandidate.getLocale())); 161cdf0e10cSrcweir 162cdf0e10cSrcweir // handle additional font attributes 163cdf0e10cSrcweir const primitive2d::TextDecoratedPortionPrimitive2D* pTCPP = 164cdf0e10cSrcweir dynamic_cast<const primitive2d::TextDecoratedPortionPrimitive2D*>( &rTextCandidate ); 165cdf0e10cSrcweir 166cdf0e10cSrcweir if( pTCPP != NULL ) 167cdf0e10cSrcweir { 168cdf0e10cSrcweir 169cdf0e10cSrcweir // set the color of text decorations 170cdf0e10cSrcweir const basegfx::BColor aTextlineColor = maBColorModifierStack.getModifiedColor(pTCPP->getTextlineColor()); 171cdf0e10cSrcweir mpOutputDevice->SetTextLineColor( Color(aTextlineColor) ); 172cdf0e10cSrcweir 173cdf0e10cSrcweir // set Overline attribute 174cdf0e10cSrcweir const FontUnderline eFontOverline(primitive2d::mapTextLineToFontUnderline( pTCPP->getFontOverline() )); 175cdf0e10cSrcweir if( eFontOverline != UNDERLINE_NONE ) 176cdf0e10cSrcweir { 177cdf0e10cSrcweir aFont.SetOverline( eFontOverline ); 178cdf0e10cSrcweir const basegfx::BColor aOverlineColor = maBColorModifierStack.getModifiedColor(pTCPP->getOverlineColor()); 179cdf0e10cSrcweir mpOutputDevice->SetOverlineColor( Color(aOverlineColor) ); 180cdf0e10cSrcweir if( pTCPP->getWordLineMode() ) 181cdf0e10cSrcweir aFont.SetWordLineMode( true ); 182cdf0e10cSrcweir } 183cdf0e10cSrcweir 184cdf0e10cSrcweir // set Underline attribute 185cdf0e10cSrcweir const FontUnderline eFontUnderline(primitive2d::mapTextLineToFontUnderline( pTCPP->getFontUnderline() )); 186cdf0e10cSrcweir if( eFontUnderline != UNDERLINE_NONE ) 187cdf0e10cSrcweir { 188cdf0e10cSrcweir aFont.SetUnderline( eFontUnderline ); 189cdf0e10cSrcweir if( pTCPP->getWordLineMode() ) 190cdf0e10cSrcweir aFont.SetWordLineMode( true ); 191cdf0e10cSrcweir //TODO: ??? if( pTCPP->getUnderlineAbove() ) 192cdf0e10cSrcweir // aFont.SetUnderlineAbove( true ); 193cdf0e10cSrcweir } 194cdf0e10cSrcweir 195cdf0e10cSrcweir // set Strikeout attribute 196cdf0e10cSrcweir const FontStrikeout eFontStrikeout(primitive2d::mapTextStrikeoutToFontStrikeout(pTCPP->getTextStrikeout())); 197cdf0e10cSrcweir 198cdf0e10cSrcweir if( eFontStrikeout != STRIKEOUT_NONE ) 199cdf0e10cSrcweir aFont.SetStrikeout( eFontStrikeout ); 200cdf0e10cSrcweir 201cdf0e10cSrcweir // set EmphasisMark attribute 202cdf0e10cSrcweir FontEmphasisMark eFontEmphasisMark = EMPHASISMARK_NONE; 203cdf0e10cSrcweir switch( pTCPP->getTextEmphasisMark() ) 204cdf0e10cSrcweir { 205cdf0e10cSrcweir default: 206cdf0e10cSrcweir DBG_WARNING1( "DrawingLayer: Unknown EmphasisMark style (%d)!", pTCPP->getTextEmphasisMark() ); 207cdf0e10cSrcweir // fall through 208cdf0e10cSrcweir case primitive2d::TEXT_EMPHASISMARK_NONE: eFontEmphasisMark = EMPHASISMARK_NONE; break; 209cdf0e10cSrcweir case primitive2d::TEXT_EMPHASISMARK_DOT: eFontEmphasisMark = EMPHASISMARK_DOT; break; 210cdf0e10cSrcweir case primitive2d::TEXT_EMPHASISMARK_CIRCLE: eFontEmphasisMark = EMPHASISMARK_CIRCLE; break; 211cdf0e10cSrcweir case primitive2d::TEXT_EMPHASISMARK_DISC: eFontEmphasisMark = EMPHASISMARK_DISC; break; 212cdf0e10cSrcweir case primitive2d::TEXT_EMPHASISMARK_ACCENT: eFontEmphasisMark = EMPHASISMARK_ACCENT; break; 213cdf0e10cSrcweir } 214cdf0e10cSrcweir 215cdf0e10cSrcweir if( eFontEmphasisMark != EMPHASISMARK_NONE ) 216cdf0e10cSrcweir { 217cdf0e10cSrcweir DBG_ASSERT( (pTCPP->getEmphasisMarkAbove() != pTCPP->getEmphasisMarkBelow()), 218cdf0e10cSrcweir "DrawingLayer: Bad EmphasisMark position!" ); 219cdf0e10cSrcweir if( pTCPP->getEmphasisMarkAbove() ) 220cdf0e10cSrcweir eFontEmphasisMark |= EMPHASISMARK_POS_ABOVE; 221cdf0e10cSrcweir else 222cdf0e10cSrcweir eFontEmphasisMark |= EMPHASISMARK_POS_BELOW; 223cdf0e10cSrcweir aFont.SetEmphasisMark( eFontEmphasisMark ); 224cdf0e10cSrcweir } 225cdf0e10cSrcweir 226cdf0e10cSrcweir // set Relief attribute 227cdf0e10cSrcweir FontRelief eFontRelief = RELIEF_NONE; 228cdf0e10cSrcweir switch( pTCPP->getTextRelief() ) 229cdf0e10cSrcweir { 230cdf0e10cSrcweir default: 231cdf0e10cSrcweir DBG_WARNING1( "DrawingLayer: Unknown Relief style (%d)!", pTCPP->getTextRelief() ); 232cdf0e10cSrcweir // fall through 233cdf0e10cSrcweir case primitive2d::TEXT_RELIEF_NONE: eFontRelief = RELIEF_NONE; break; 234cdf0e10cSrcweir case primitive2d::TEXT_RELIEF_EMBOSSED: eFontRelief = RELIEF_EMBOSSED; break; 235cdf0e10cSrcweir case primitive2d::TEXT_RELIEF_ENGRAVED: eFontRelief = RELIEF_ENGRAVED; break; 236cdf0e10cSrcweir } 237cdf0e10cSrcweir 238cdf0e10cSrcweir if( eFontRelief != RELIEF_NONE ) 239cdf0e10cSrcweir aFont.SetRelief( eFontRelief ); 240cdf0e10cSrcweir 241cdf0e10cSrcweir // set Shadow attribute 242cdf0e10cSrcweir if( pTCPP->getShadow() ) 243cdf0e10cSrcweir aFont.SetShadow( true ); 244cdf0e10cSrcweir } 245cdf0e10cSrcweir 246cdf0e10cSrcweir // create transformed integer DXArray in view coordinate system 247cdf0e10cSrcweir ::std::vector< sal_Int32 > aTransformedDXArray; 248cdf0e10cSrcweir 249cdf0e10cSrcweir if(rTextCandidate.getDXArray().size()) 250cdf0e10cSrcweir { 251cdf0e10cSrcweir aTransformedDXArray.reserve(rTextCandidate.getDXArray().size()); 252cdf0e10cSrcweir const basegfx::B2DVector aPixelVector(maCurrentTransformation * basegfx::B2DVector(1.0, 0.0)); 253cdf0e10cSrcweir const double fPixelVectorFactor(aPixelVector.getLength()); 254cdf0e10cSrcweir 255cdf0e10cSrcweir for(::std::vector< double >::const_iterator aStart(rTextCandidate.getDXArray().begin()); 256cdf0e10cSrcweir aStart != rTextCandidate.getDXArray().end(); aStart++) 257cdf0e10cSrcweir { 258cdf0e10cSrcweir aTransformedDXArray.push_back(basegfx::fround((*aStart) * fPixelVectorFactor)); 259cdf0e10cSrcweir } 260cdf0e10cSrcweir } 261cdf0e10cSrcweir 262cdf0e10cSrcweir // set parameters and paint text snippet 263cdf0e10cSrcweir const basegfx::BColor aRGBFontColor(maBColorModifierStack.getModifiedColor(rTextCandidate.getFontColor())); 264cdf0e10cSrcweir const basegfx::B2DPoint aPoint(aLocalTransform * basegfx::B2DPoint(0.0, 0.0)); 265cdf0e10cSrcweir const Point aStartPoint(basegfx::fround(aPoint.getX()), basegfx::fround(aPoint.getY())); 266cdf0e10cSrcweir const sal_uInt32 nOldLayoutMode(mpOutputDevice->GetLayoutMode()); 267cdf0e10cSrcweir 268cdf0e10cSrcweir if(rTextCandidate.getFontAttribute().getRTL()) 269cdf0e10cSrcweir { 270cdf0e10cSrcweir sal_uInt32 nRTLLayoutMode(nOldLayoutMode & ~(TEXT_LAYOUT_COMPLEX_DISABLED|TEXT_LAYOUT_BIDI_STRONG)); 271cdf0e10cSrcweir nRTLLayoutMode |= TEXT_LAYOUT_BIDI_RTL|TEXT_LAYOUT_TEXTORIGIN_LEFT; 272cdf0e10cSrcweir mpOutputDevice->SetLayoutMode(nRTLLayoutMode); 273cdf0e10cSrcweir } 274cdf0e10cSrcweir 275cdf0e10cSrcweir mpOutputDevice->SetFont(aFont); 276cdf0e10cSrcweir mpOutputDevice->SetTextColor(Color(aRGBFontColor)); 277cdf0e10cSrcweir 278cdf0e10cSrcweir if(aTransformedDXArray.size()) 279cdf0e10cSrcweir { 280cdf0e10cSrcweir mpOutputDevice->DrawTextArray( 281cdf0e10cSrcweir aStartPoint, 282cdf0e10cSrcweir rTextCandidate.getText(), 283cdf0e10cSrcweir &(aTransformedDXArray[0]), 284cdf0e10cSrcweir rTextCandidate.getTextPosition(), 285cdf0e10cSrcweir rTextCandidate.getTextLength()); 286cdf0e10cSrcweir } 287cdf0e10cSrcweir else 288cdf0e10cSrcweir { 289cdf0e10cSrcweir mpOutputDevice->DrawText( 290cdf0e10cSrcweir aStartPoint, 291cdf0e10cSrcweir rTextCandidate.getText(), 292cdf0e10cSrcweir rTextCandidate.getTextPosition(), 293cdf0e10cSrcweir rTextCandidate.getTextLength()); 294cdf0e10cSrcweir } 295cdf0e10cSrcweir 296cdf0e10cSrcweir if(rTextCandidate.getFontAttribute().getRTL()) 297cdf0e10cSrcweir { 298cdf0e10cSrcweir mpOutputDevice->SetLayoutMode(nOldLayoutMode); 299cdf0e10cSrcweir } 300cdf0e10cSrcweir 301cdf0e10cSrcweir bPrimitiveAccepted = true; 302cdf0e10cSrcweir } 303cdf0e10cSrcweir } 304cdf0e10cSrcweir 305cdf0e10cSrcweir if(!bPrimitiveAccepted) 306cdf0e10cSrcweir { 307cdf0e10cSrcweir // let break down 308cdf0e10cSrcweir process(rTextCandidate.get2DDecomposition(getViewInformation2D())); 309cdf0e10cSrcweir } 310cdf0e10cSrcweir } 311cdf0e10cSrcweir 312cdf0e10cSrcweir // direct draw of hairline RenderPolygonHairlinePrimitive2D(const primitive2d::PolygonHairlinePrimitive2D & rPolygonCandidate,bool bPixelBased)313cdf0e10cSrcweir void VclProcessor2D::RenderPolygonHairlinePrimitive2D(const primitive2d::PolygonHairlinePrimitive2D& rPolygonCandidate, bool bPixelBased) 314cdf0e10cSrcweir { 315cdf0e10cSrcweir const basegfx::BColor aHairlineColor(maBColorModifierStack.getModifiedColor(rPolygonCandidate.getBColor())); 316cdf0e10cSrcweir mpOutputDevice->SetLineColor(Color(aHairlineColor)); 317cdf0e10cSrcweir mpOutputDevice->SetFillColor(); 318cdf0e10cSrcweir 319cdf0e10cSrcweir basegfx::B2DPolygon aLocalPolygon(rPolygonCandidate.getB2DPolygon()); 320cdf0e10cSrcweir aLocalPolygon.transform(maCurrentTransformation); 321cdf0e10cSrcweir 322cdf0e10cSrcweir static bool bCheckTrapezoidDecomposition(false); 323cdf0e10cSrcweir static bool bShowOutlinesThere(false); 324cdf0e10cSrcweir if(bCheckTrapezoidDecomposition) 325cdf0e10cSrcweir { 326cdf0e10cSrcweir // clip against discrete ViewPort 327cdf0e10cSrcweir const basegfx::B2DRange& rDiscreteViewport = getViewInformation2D().getDiscreteViewport(); 328cdf0e10cSrcweir basegfx::B2DPolyPolygon aLocalPolyPolygon(basegfx::tools::clipPolygonOnRange( 329cdf0e10cSrcweir aLocalPolygon, rDiscreteViewport, true, false)); 330cdf0e10cSrcweir 331cdf0e10cSrcweir if(aLocalPolyPolygon.count()) 332cdf0e10cSrcweir { 333cdf0e10cSrcweir // subdivide 334cdf0e10cSrcweir aLocalPolyPolygon = basegfx::tools::adaptiveSubdivideByDistance( 335cdf0e10cSrcweir aLocalPolyPolygon, 0.5); 336cdf0e10cSrcweir 337cdf0e10cSrcweir // trapezoidize 338cdf0e10cSrcweir static double fLineWidth(2.0); 339cdf0e10cSrcweir basegfx::B2DTrapezoidVector aB2DTrapezoidVector; 340cdf0e10cSrcweir basegfx::tools::createLineTrapezoidFromB2DPolyPolygon(aB2DTrapezoidVector, aLocalPolyPolygon, fLineWidth); 341cdf0e10cSrcweir 342cdf0e10cSrcweir const sal_uInt32 nCount(aB2DTrapezoidVector.size()); 343cdf0e10cSrcweir 344cdf0e10cSrcweir if(nCount) 345cdf0e10cSrcweir { 346cdf0e10cSrcweir basegfx::BColor aInvPolygonColor(aHairlineColor); 347cdf0e10cSrcweir aInvPolygonColor.invert(); 348cdf0e10cSrcweir 349cdf0e10cSrcweir for(sal_uInt32 a(0); a < nCount; a++) 350cdf0e10cSrcweir { 351cdf0e10cSrcweir const basegfx::B2DPolygon aTempPolygon(aB2DTrapezoidVector[a].getB2DPolygon()); 352cdf0e10cSrcweir 353cdf0e10cSrcweir if(bShowOutlinesThere) 354cdf0e10cSrcweir { 355cdf0e10cSrcweir mpOutputDevice->SetFillColor(Color(aHairlineColor)); 356cdf0e10cSrcweir mpOutputDevice->SetLineColor(); 357cdf0e10cSrcweir } 358cdf0e10cSrcweir 359cdf0e10cSrcweir mpOutputDevice->DrawPolygon(aTempPolygon); 360cdf0e10cSrcweir 361cdf0e10cSrcweir if(bShowOutlinesThere) 362cdf0e10cSrcweir { 363cdf0e10cSrcweir mpOutputDevice->SetFillColor(); 364cdf0e10cSrcweir mpOutputDevice->SetLineColor(Color(aInvPolygonColor)); 365cdf0e10cSrcweir mpOutputDevice->DrawPolyLine(aTempPolygon, 0.0); 366cdf0e10cSrcweir } 367cdf0e10cSrcweir } 368cdf0e10cSrcweir } 369cdf0e10cSrcweir } 370cdf0e10cSrcweir } 371cdf0e10cSrcweir else 372cdf0e10cSrcweir { 373cdf0e10cSrcweir if(bPixelBased && getOptionsDrawinglayer().IsAntiAliasing() && getOptionsDrawinglayer().IsSnapHorVerLinesToDiscrete()) 374cdf0e10cSrcweir { 375cdf0e10cSrcweir // #i98289# 376cdf0e10cSrcweir // when a Hairline is painted and AntiAliasing is on the option SnapHorVerLinesToDiscrete 377cdf0e10cSrcweir // allows to suppress AntiAliasing for pure horizontal or vertical lines. This is done since 378cdf0e10cSrcweir // not-AntiAliased such lines look more pleasing to the eye (e.g. 2D chart content). This 379cdf0e10cSrcweir // NEEDS to be done in discrete coordinates, so only useful for pixel based rendering. 380cdf0e10cSrcweir aLocalPolygon = basegfx::tools::snapPointsOfHorizontalOrVerticalEdges(aLocalPolygon); 381cdf0e10cSrcweir } 382cdf0e10cSrcweir 383cdf0e10cSrcweir mpOutputDevice->DrawPolyLine(aLocalPolygon, 0.0); 384cdf0e10cSrcweir } 385cdf0e10cSrcweir } 386cdf0e10cSrcweir 387cdf0e10cSrcweir // direct draw of transformed BitmapEx primitive RenderBitmapPrimitive2D(const primitive2d::BitmapPrimitive2D & rBitmapCandidate)388cdf0e10cSrcweir void VclProcessor2D::RenderBitmapPrimitive2D(const primitive2d::BitmapPrimitive2D& rBitmapCandidate) 389cdf0e10cSrcweir { 390b0e53128SArmin Le Grand BitmapEx aBitmapEx(rBitmapCandidate.getBitmapEx()); 391cf95e506SArmin Le Grand const basegfx::B2DHomMatrix aLocalTransform(maCurrentTransformation * rBitmapCandidate.getTransform()); 392cdf0e10cSrcweir 393cdf0e10cSrcweir if(maBColorModifierStack.count()) 394cdf0e10cSrcweir { 3955f27b83cSArmin Le Grand aBitmapEx = aBitmapEx.ModifyBitmapEx(maBColorModifierStack); 396cdf0e10cSrcweir 397cdf0e10cSrcweir if(aBitmapEx.IsEmpty()) 398cdf0e10cSrcweir { 399cdf0e10cSrcweir // color gets completely replaced, get it 400cdf0e10cSrcweir const basegfx::BColor aModifiedColor(maBColorModifierStack.getModifiedColor(basegfx::BColor())); 401cdf0e10cSrcweir basegfx::B2DPolygon aPolygon(basegfx::tools::createUnitPolygon()); 402cdf0e10cSrcweir aPolygon.transform(aLocalTransform); 403cdf0e10cSrcweir 404cdf0e10cSrcweir mpOutputDevice->SetFillColor(Color(aModifiedColor)); 405cdf0e10cSrcweir mpOutputDevice->SetLineColor(); 406cdf0e10cSrcweir mpOutputDevice->DrawPolygon(aPolygon); 407cdf0e10cSrcweir 408b0e53128SArmin Le Grand return; 409cdf0e10cSrcweir } 410cdf0e10cSrcweir } 411cdf0e10cSrcweir 4125496114cSArmin Le Grand // #122923# do no longer add Alpha channel here; the right place to do this is when really 4135496114cSArmin Le Grand // the own transformer is used (see OutputDevice::DrawTransformedBitmapEx). 4145f27b83cSArmin Le Grand 4155f27b83cSArmin Le Grand // draw using OutputDevice'sDrawTransformedBitmapEx 4165f27b83cSArmin Le Grand mpOutputDevice->DrawTransformedBitmapEx(aLocalTransform, aBitmapEx); 417cdf0e10cSrcweir } 418cdf0e10cSrcweir RenderFillGraphicPrimitive2D(const primitive2d::FillGraphicPrimitive2D & rFillBitmapCandidate)419035a2f44SArmin Le Grand void VclProcessor2D::RenderFillGraphicPrimitive2D(const primitive2d::FillGraphicPrimitive2D& rFillBitmapCandidate) 420cdf0e10cSrcweir { 421035a2f44SArmin Le Grand const attribute::FillGraphicAttribute& rFillGraphicAttribute(rFillBitmapCandidate.getFillGraphic()); 422cdf0e10cSrcweir bool bPrimitiveAccepted(false); 423035a2f44SArmin Le Grand static bool bTryTilingDirect = true; 424cdf0e10cSrcweir 425035a2f44SArmin Le Grand // #121194# when tiling is used and content is bitmap-based, do direct tiling in the 426035a2f44SArmin Le Grand // renderer on pixel base to ensure tight fitting. Do not do this when 427035a2f44SArmin Le Grand // the fill is rotated or sheared. 428cdf0e10cSrcweir 429035a2f44SArmin Le Grand // ovveride static bool (for debug) and tiling is active 430035a2f44SArmin Le Grand if(bTryTilingDirect && rFillGraphicAttribute.getTiling()) 431035a2f44SArmin Le Grand { 432035a2f44SArmin Le Grand // content is bitmap(ex) 433035a2f44SArmin Le Grand // 434035a2f44SArmin Le Grand // for SVG support, force decomposition when SVG is present. This will lead to use 435035a2f44SArmin Le Grand // the primitive representation of the svg directly. 436035a2f44SArmin Le Grand // 437035a2f44SArmin Le Grand // when graphic is animated, force decomposition to use the correct graphic, else 438035a2f44SArmin Le Grand // fill style will not be animated 439035a2f44SArmin Le Grand if(GRAPHIC_BITMAP == rFillGraphicAttribute.getGraphic().GetType() 440035a2f44SArmin Le Grand && !rFillGraphicAttribute.getGraphic().getSvgData().get() 441035a2f44SArmin Le Grand && !rFillGraphicAttribute.getGraphic().IsAnimated()) 442035a2f44SArmin Le Grand { 443035a2f44SArmin Le Grand // decompose matrix to check for shear, rotate and mirroring 444035a2f44SArmin Le Grand basegfx::B2DHomMatrix aLocalTransform(maCurrentTransformation * rFillBitmapCandidate.getTransformation()); 445035a2f44SArmin Le Grand basegfx::B2DVector aScale, aTranslate; 446035a2f44SArmin Le Grand double fRotate, fShearX; 447035a2f44SArmin Le Grand aLocalTransform.decompose(aScale, aTranslate, fRotate, fShearX); 448035a2f44SArmin Le Grand 449035a2f44SArmin Le Grand // when nopt rotated/sheared 450035a2f44SArmin Le Grand if(basegfx::fTools::equalZero(fRotate) && basegfx::fTools::equalZero(fShearX)) 451035a2f44SArmin Le Grand { 452035a2f44SArmin Le Grand // no shear or rotate, draw direct in pixel coordinates 453035a2f44SArmin Le Grand bPrimitiveAccepted = true; 454035a2f44SArmin Le Grand 455035a2f44SArmin Le Grand // transform object range to device coordinates (pixels). Use 456035a2f44SArmin Le Grand // the device transformation for better accuracy 457035a2f44SArmin Le Grand basegfx::B2DRange aObjectRange(aTranslate, aTranslate + aScale); 458035a2f44SArmin Le Grand aObjectRange.transform(mpOutputDevice->GetViewTransformation()); 459035a2f44SArmin Le Grand 460035a2f44SArmin Le Grand // extract discrete size of object 461035a2f44SArmin Le Grand const sal_Int32 nOWidth(basegfx::fround(aObjectRange.getWidth())); 462035a2f44SArmin Le Grand const sal_Int32 nOHeight(basegfx::fround(aObjectRange.getHeight())); 463cdf0e10cSrcweir 464cdf0e10cSrcweir // only do something when object has a size in discrete units 465cdf0e10cSrcweir if(nOWidth > 0 && nOHeight > 0) 466cdf0e10cSrcweir { 467035a2f44SArmin Le Grand // transform graphic range to device coordinates (pixels). Use 468035a2f44SArmin Le Grand // the device transformation for better accuracy 469035a2f44SArmin Le Grand basegfx::B2DRange aGraphicRange(rFillGraphicAttribute.getGraphicRange()); 470035a2f44SArmin Le Grand aGraphicRange.transform(mpOutputDevice->GetViewTransformation() * aLocalTransform); 471035a2f44SArmin Le Grand 472035a2f44SArmin Le Grand // extract discrete size of graphic 4731f69a0e2SArmin Le Grand // caution: when getting to zero, nothing would be painted; thus, do not allow this 4741f69a0e2SArmin Le Grand const sal_Int32 nBWidth(std::max(sal_Int32(1), basegfx::fround(aGraphicRange.getWidth()))); 4751f69a0e2SArmin Le Grand const sal_Int32 nBHeight(std::max(sal_Int32(1), basegfx::fround(aGraphicRange.getHeight()))); 476cdf0e10cSrcweir 477cdf0e10cSrcweir // only do something when bitmap fill has a size in discrete units 478cdf0e10cSrcweir if(nBWidth > 0 && nBHeight > 0) 479cdf0e10cSrcweir { 480cdf0e10cSrcweir // nBWidth, nBHeight is the pixel size of the neede bitmap. To not need to scale it 481cdf0e10cSrcweir // in vcl many times, create a size-optimized version 482cdf0e10cSrcweir const Size aNeededBitmapSizePixel(nBWidth, nBHeight); 4834665f8d3SArmin Le Grand BitmapEx aBitmapEx(rFillGraphicAttribute.getGraphic().GetBitmapEx()); 4844665f8d3SArmin Le Grand static bool bEnablePreScaling(true); 4854665f8d3SArmin Le Grand const bool bPreScaled(bEnablePreScaling && nBWidth * nBHeight < (250 * 250)); 4864665f8d3SArmin Le Grand 4871f69a0e2SArmin Le Grand // ... but only up to a maximum size, else it gets too expensive 4884665f8d3SArmin Le Grand if(bPreScaled) 4894665f8d3SArmin Le Grand { 4901f69a0e2SArmin Le Grand // if color depth is below 24bit, expand before scaling for better quality. 4911f69a0e2SArmin Le Grand // This is even needed for low colors, else the scale will produce 4921f69a0e2SArmin Le Grand // a bitmap in gray or Black/White (!) 4931f69a0e2SArmin Le Grand if(aBitmapEx.GetBitCount() < 24) 4941f69a0e2SArmin Le Grand { 4951f69a0e2SArmin Le Grand aBitmapEx.Convert(BMP_CONVERSION_24BIT); 4961f69a0e2SArmin Le Grand } 4971f69a0e2SArmin Le Grand 4984665f8d3SArmin Le Grand aBitmapEx.Scale(aNeededBitmapSizePixel, BMP_SCALE_INTERPOLATE); 4994665f8d3SArmin Le Grand } 5004665f8d3SArmin Le Grand 501035a2f44SArmin Le Grand bool bPainted(false); 502035a2f44SArmin Le Grand 503035a2f44SArmin Le Grand if(maBColorModifierStack.count()) 504035a2f44SArmin Le Grand { 505035a2f44SArmin Le Grand // when color modifier, apply to bitmap 5065f27b83cSArmin Le Grand aBitmapEx = aBitmapEx.ModifyBitmapEx(maBColorModifierStack); 507035a2f44SArmin Le Grand 508035a2f44SArmin Le Grand // impModifyBitmapEx uses empty bitmap as sign to return that 509035a2f44SArmin Le Grand // the content will be completely replaced to mono color, use shortcut 510035a2f44SArmin Le Grand if(aBitmapEx.IsEmpty()) 511035a2f44SArmin Le Grand { 512035a2f44SArmin Le Grand // color gets completely replaced, get it 513035a2f44SArmin Le Grand const basegfx::BColor aModifiedColor(maBColorModifierStack.getModifiedColor(basegfx::BColor())); 514035a2f44SArmin Le Grand basegfx::B2DPolygon aPolygon(basegfx::tools::createUnitPolygon()); 515035a2f44SArmin Le Grand aPolygon.transform(aLocalTransform); 516035a2f44SArmin Le Grand 517035a2f44SArmin Le Grand mpOutputDevice->SetFillColor(Color(aModifiedColor)); 518035a2f44SArmin Le Grand mpOutputDevice->SetLineColor(); 519035a2f44SArmin Le Grand mpOutputDevice->DrawPolygon(aPolygon); 520035a2f44SArmin Le Grand 521035a2f44SArmin Le Grand bPainted = true; 522035a2f44SArmin Le Grand } 523035a2f44SArmin Le Grand } 524035a2f44SArmin Le Grand 525035a2f44SArmin Le Grand if(!bPainted) 526035a2f44SArmin Le Grand { 527035a2f44SArmin Le Grand sal_Int32 nBLeft(basegfx::fround(aGraphicRange.getMinX())); 528035a2f44SArmin Le Grand sal_Int32 nBTop(basegfx::fround(aGraphicRange.getMinY())); 529035a2f44SArmin Le Grand const sal_Int32 nOLeft(basegfx::fround(aObjectRange.getMinX())); 530035a2f44SArmin Le Grand const sal_Int32 nOTop(basegfx::fround(aObjectRange.getMinY())); 531035a2f44SArmin Le Grand sal_Int32 nPosX(0); 532035a2f44SArmin Le Grand sal_Int32 nPosY(0); 533035a2f44SArmin Le Grand 534035a2f44SArmin Le Grand if(nBLeft > nOLeft) 535035a2f44SArmin Le Grand { 536035a2f44SArmin Le Grand const sal_Int32 nDiff((nBLeft / nBWidth) + 1); 537035a2f44SArmin Le Grand 538035a2f44SArmin Le Grand nPosX -= nDiff; 539035a2f44SArmin Le Grand nBLeft -= nDiff * nBWidth; 540035a2f44SArmin Le Grand } 541035a2f44SArmin Le Grand 542035a2f44SArmin Le Grand if(nBLeft + nBWidth <= nOLeft) 543035a2f44SArmin Le Grand { 544035a2f44SArmin Le Grand const sal_Int32 nDiff(-nBLeft / nBWidth); 545035a2f44SArmin Le Grand 546035a2f44SArmin Le Grand nPosX += nDiff; 547035a2f44SArmin Le Grand nBLeft += nDiff * nBWidth; 548035a2f44SArmin Le Grand } 549035a2f44SArmin Le Grand 550035a2f44SArmin Le Grand if(nBTop > nOTop) 551035a2f44SArmin Le Grand { 552035a2f44SArmin Le Grand const sal_Int32 nDiff((nBTop / nBHeight) + 1); 553035a2f44SArmin Le Grand 554035a2f44SArmin Le Grand nPosY -= nDiff; 555035a2f44SArmin Le Grand nBTop -= nDiff * nBHeight; 556035a2f44SArmin Le Grand } 557035a2f44SArmin Le Grand 558035a2f44SArmin Le Grand if(nBTop + nBHeight <= nOTop) 559035a2f44SArmin Le Grand { 560035a2f44SArmin Le Grand const sal_Int32 nDiff(-nBTop / nBHeight); 561035a2f44SArmin Le Grand 562035a2f44SArmin Le Grand nPosY += nDiff; 563035a2f44SArmin Le Grand nBTop += nDiff * nBHeight; 564035a2f44SArmin Le Grand } 565035a2f44SArmin Le Grand 566035a2f44SArmin Le Grand // prepare OutDev 567035a2f44SArmin Le Grand const Point aEmptyPoint(0, 0); 568035a2f44SArmin Le Grand const Rectangle aVisiblePixel(aEmptyPoint, mpOutputDevice->GetOutputSizePixel()); 569035a2f44SArmin Le Grand const bool bWasEnabled(mpOutputDevice->IsMapModeEnabled()); 570035a2f44SArmin Le Grand mpOutputDevice->EnableMapMode(false); 571035a2f44SArmin Le Grand 572035a2f44SArmin Le Grand // check if offset is used 573035a2f44SArmin Le Grand const sal_Int32 nOffsetX(basegfx::fround(rFillGraphicAttribute.getOffsetX() * nBWidth)); 574035a2f44SArmin Le Grand 575035a2f44SArmin Le Grand if(nOffsetX) 576035a2f44SArmin Le Grand { 577035a2f44SArmin Le Grand // offset in X, so iterate over Y first and draw lines 578035a2f44SArmin Le Grand for(sal_Int32 nYPos(nBTop); nYPos < nOTop + nOHeight; nYPos += nBHeight, nPosY++) 579035a2f44SArmin Le Grand { 580035a2f44SArmin Le Grand for(sal_Int32 nXPos(nPosY % 2 ? nBLeft - nBWidth + nOffsetX : nBLeft); 581035a2f44SArmin Le Grand nXPos < nOLeft + nOWidth; nXPos += nBWidth) 582035a2f44SArmin Le Grand { 583035a2f44SArmin Le Grand const Rectangle aOutRectPixel(Point(nXPos, nYPos), aNeededBitmapSizePixel); 584035a2f44SArmin Le Grand 585035a2f44SArmin Le Grand if(aOutRectPixel.IsOver(aVisiblePixel)) 586035a2f44SArmin Le Grand { 5874665f8d3SArmin Le Grand if(bPreScaled) 5884665f8d3SArmin Le Grand { 5894665f8d3SArmin Le Grand mpOutputDevice->DrawBitmapEx(aOutRectPixel.TopLeft(), aBitmapEx); 5904665f8d3SArmin Le Grand } 5914665f8d3SArmin Le Grand else 5924665f8d3SArmin Le Grand { 5934665f8d3SArmin Le Grand mpOutputDevice->DrawBitmapEx(aOutRectPixel.TopLeft(), aNeededBitmapSizePixel, aBitmapEx); 5944665f8d3SArmin Le Grand } 595035a2f44SArmin Le Grand } 596035a2f44SArmin Le Grand } 597035a2f44SArmin Le Grand } 598035a2f44SArmin Le Grand } 599035a2f44SArmin Le Grand else 600035a2f44SArmin Le Grand { 601035a2f44SArmin Le Grand // check if offset is used 602035a2f44SArmin Le Grand const sal_Int32 nOffsetY(basegfx::fround(rFillGraphicAttribute.getOffsetY() * nBHeight)); 603035a2f44SArmin Le Grand 604035a2f44SArmin Le Grand // possible offset in Y, so iterate over X first and draw columns 605035a2f44SArmin Le Grand for(sal_Int32 nXPos(nBLeft); nXPos < nOLeft + nOWidth; nXPos += nBWidth, nPosX++) 606035a2f44SArmin Le Grand { 607035a2f44SArmin Le Grand for(sal_Int32 nYPos(nPosX % 2 ? nBTop - nBHeight + nOffsetY : nBTop); 608035a2f44SArmin Le Grand nYPos < nOTop + nOHeight; nYPos += nBHeight) 609035a2f44SArmin Le Grand { 610035a2f44SArmin Le Grand const Rectangle aOutRectPixel(Point(nXPos, nYPos), aNeededBitmapSizePixel); 611035a2f44SArmin Le Grand 612035a2f44SArmin Le Grand if(aOutRectPixel.IsOver(aVisiblePixel)) 613035a2f44SArmin Le Grand { 6144665f8d3SArmin Le Grand if(bPreScaled) 6154665f8d3SArmin Le Grand { 6164665f8d3SArmin Le Grand mpOutputDevice->DrawBitmapEx(aOutRectPixel.TopLeft(), aBitmapEx); 6174665f8d3SArmin Le Grand } 6184665f8d3SArmin Le Grand else 6194665f8d3SArmin Le Grand { 6204665f8d3SArmin Le Grand mpOutputDevice->DrawBitmapEx(aOutRectPixel.TopLeft(), aNeededBitmapSizePixel, aBitmapEx); 6214665f8d3SArmin Le Grand } 622035a2f44SArmin Le Grand } 623035a2f44SArmin Le Grand } 624035a2f44SArmin Le Grand } 625035a2f44SArmin Le Grand } 626035a2f44SArmin Le Grand 627035a2f44SArmin Le Grand // restore OutDev 628035a2f44SArmin Le Grand mpOutputDevice->EnableMapMode(bWasEnabled); 629035a2f44SArmin Le Grand } 630cdf0e10cSrcweir } 631cdf0e10cSrcweir } 632035a2f44SArmin Le Grand } 633035a2f44SArmin Le Grand } 634035a2f44SArmin Le Grand } 635cdf0e10cSrcweir 636cdf0e10cSrcweir if(!bPrimitiveAccepted) 637cdf0e10cSrcweir { 638cdf0e10cSrcweir // do not accept, use decomposition 639cdf0e10cSrcweir process(rFillBitmapCandidate.get2DDecomposition(getViewInformation2D())); 640cdf0e10cSrcweir } 641cdf0e10cSrcweir } 642cdf0e10cSrcweir 643035a2f44SArmin Le Grand // direct draw of Graphic RenderPolyPolygonGraphicPrimitive2D(const primitive2d::PolyPolygonGraphicPrimitive2D & rPolygonCandidate)644035a2f44SArmin Le Grand void VclProcessor2D::RenderPolyPolygonGraphicPrimitive2D(const primitive2d::PolyPolygonGraphicPrimitive2D& rPolygonCandidate) 645cdf0e10cSrcweir { 646035a2f44SArmin Le Grand bool bDone(false); 647035a2f44SArmin Le Grand const basegfx::B2DPolyPolygon& rPolyPolygon = rPolygonCandidate.getB2DPolyPolygon(); 648cdf0e10cSrcweir 649035a2f44SArmin Le Grand // #121194# Todo: check if this works 650035a2f44SArmin Le Grand if(!rPolyPolygon.count()) 651035a2f44SArmin Le Grand { 652035a2f44SArmin Le Grand // empty polyPolygon, done 653035a2f44SArmin Le Grand bDone = true; 654035a2f44SArmin Le Grand } 655035a2f44SArmin Le Grand else 656035a2f44SArmin Le Grand { 657035a2f44SArmin Le Grand const attribute::FillGraphicAttribute& rFillGraphicAttribute = rPolygonCandidate.getFillGraphic(); 658cdf0e10cSrcweir 659035a2f44SArmin Le Grand // try to catch cases where the graphic will be color-modified to a single 660035a2f44SArmin Le Grand // color (e.g. shadow) 661035a2f44SArmin Le Grand switch(rFillGraphicAttribute.getGraphic().GetType()) 662035a2f44SArmin Le Grand { 663035a2f44SArmin Le Grand case GRAPHIC_GDIMETAFILE: 664035a2f44SArmin Le Grand { 665*49c58f9bSArmin Le Grand // metafiles are potentially transparent, cannot optimize, not done 666035a2f44SArmin Le Grand break; 667035a2f44SArmin Le Grand } 668035a2f44SArmin Le Grand case GRAPHIC_BITMAP: 669035a2f44SArmin Le Grand { 670035a2f44SArmin Le Grand if(!rFillGraphicAttribute.getGraphic().IsTransparent() && !rFillGraphicAttribute.getGraphic().IsAlpha()) 671035a2f44SArmin Le Grand { 672035a2f44SArmin Le Grand // bitmap is not transparent and has no alpha 673035a2f44SArmin Le Grand const sal_uInt32 nBColorModifierStackCount(maBColorModifierStack.count()); 674cdf0e10cSrcweir 675035a2f44SArmin Le Grand if(nBColorModifierStackCount) 676035a2f44SArmin Le Grand { 677*49c58f9bSArmin Le Grand const basegfx::BColorModifierSharedPtr& rTopmostModifier = maBColorModifierStack.getBColorModifier(nBColorModifierStackCount - 1); 678*49c58f9bSArmin Le Grand const basegfx::BColorModifier_replace* pReplacer = dynamic_cast< const basegfx::BColorModifier_replace* >(rTopmostModifier.get()); 679035a2f44SArmin Le Grand 680*49c58f9bSArmin Le Grand if(pReplacer) 681035a2f44SArmin Le Grand { 682035a2f44SArmin Le Grand // the bitmap fill is in unified color, so we can replace it with 683035a2f44SArmin Le Grand // a single polygon fill. The form of the fill depends on tiling 684035a2f44SArmin Le Grand if(rFillGraphicAttribute.getTiling()) 685035a2f44SArmin Le Grand { 686035a2f44SArmin Le Grand // with tiling, fill the whole PolyPolygon with the modifier color 687035a2f44SArmin Le Grand basegfx::B2DPolyPolygon aLocalPolyPolygon(rPolyPolygon); 688035a2f44SArmin Le Grand 689035a2f44SArmin Le Grand aLocalPolyPolygon.transform(maCurrentTransformation); 690035a2f44SArmin Le Grand mpOutputDevice->SetLineColor(); 691*49c58f9bSArmin Le Grand mpOutputDevice->SetFillColor(Color(pReplacer->getBColor())); 692035a2f44SArmin Le Grand mpOutputDevice->DrawPolyPolygon(aLocalPolyPolygon); 693035a2f44SArmin Le Grand } 694035a2f44SArmin Le Grand else 695035a2f44SArmin Le Grand { 696035a2f44SArmin Le Grand // without tiling, only the area common to the bitmap tile and the 697035a2f44SArmin Le Grand // PolyPolygon is filled. Create the bitmap tile area in object 698035a2f44SArmin Le Grand // coordinates. For this, the object transformation needs to be created 699035a2f44SArmin Le Grand // from the already scaled PolyPolygon. The tile area in object 700035a2f44SArmin Le Grand // coordinates wil always be non-rotated, so it's not necessary to 701035a2f44SArmin Le Grand // work with a polygon here 702035a2f44SArmin Le Grand basegfx::B2DRange aTileRange(rFillGraphicAttribute.getGraphicRange()); 703035a2f44SArmin Le Grand const basegfx::B2DRange aPolyPolygonRange(rPolyPolygon.getB2DRange()); 704035a2f44SArmin Le Grand const basegfx::B2DHomMatrix aNewObjectTransform( 705035a2f44SArmin Le Grand basegfx::tools::createScaleTranslateB2DHomMatrix( 706035a2f44SArmin Le Grand aPolyPolygonRange.getRange(), 707035a2f44SArmin Le Grand aPolyPolygonRange.getMinimum())); 708035a2f44SArmin Le Grand 709035a2f44SArmin Le Grand aTileRange.transform(aNewObjectTransform); 710035a2f44SArmin Le Grand 711035a2f44SArmin Le Grand // now clip the object polyPolygon against the tile range 712035a2f44SArmin Le Grand // to get the common area 713035a2f44SArmin Le Grand basegfx::B2DPolyPolygon aTarget = basegfx::tools::clipPolyPolygonOnRange( 714035a2f44SArmin Le Grand rPolyPolygon, 715035a2f44SArmin Le Grand aTileRange, 716035a2f44SArmin Le Grand true, 717035a2f44SArmin Le Grand false); 718035a2f44SArmin Le Grand 719035a2f44SArmin Le Grand if(aTarget.count()) 720035a2f44SArmin Le Grand { 721035a2f44SArmin Le Grand aTarget.transform(maCurrentTransformation); 722035a2f44SArmin Le Grand mpOutputDevice->SetLineColor(); 723*49c58f9bSArmin Le Grand mpOutputDevice->SetFillColor(Color(pReplacer->getBColor())); 724035a2f44SArmin Le Grand mpOutputDevice->DrawPolyPolygon(aTarget); 725035a2f44SArmin Le Grand } 726035a2f44SArmin Le Grand } 727035a2f44SArmin Le Grand 728035a2f44SArmin Le Grand // simplified output executed, we are done 729035a2f44SArmin Le Grand bDone = true; 730035a2f44SArmin Le Grand } 731035a2f44SArmin Le Grand } 732035a2f44SArmin Le Grand } 733035a2f44SArmin Le Grand break; 734035a2f44SArmin Le Grand } 735035a2f44SArmin Le Grand default: //GRAPHIC_NONE, GRAPHIC_DEFAULT 736035a2f44SArmin Le Grand { 737035a2f44SArmin Le Grand // empty graphic, we are done 738035a2f44SArmin Le Grand bDone = true; 739035a2f44SArmin Le Grand break; 740035a2f44SArmin Le Grand } 741035a2f44SArmin Le Grand } 742035a2f44SArmin Le Grand } 743cdf0e10cSrcweir 744035a2f44SArmin Le Grand if(!bDone) 745035a2f44SArmin Le Grand { 746035a2f44SArmin Le Grand // use default decomposition 747035a2f44SArmin Le Grand process(rPolygonCandidate.get2DDecomposition(getViewInformation2D())); 748035a2f44SArmin Le Grand } 749035a2f44SArmin Le Grand } 750cdf0e10cSrcweir 751cdf0e10cSrcweir // mask group. Force output to VDev and create mask from given mask RenderMaskPrimitive2DPixel(const primitive2d::MaskPrimitive2D & rMaskCandidate)752cdf0e10cSrcweir void VclProcessor2D::RenderMaskPrimitive2DPixel(const primitive2d::MaskPrimitive2D& rMaskCandidate) 753cdf0e10cSrcweir { 754cdf0e10cSrcweir if(rMaskCandidate.getChildren().hasElements()) 755cdf0e10cSrcweir { 756cdf0e10cSrcweir basegfx::B2DPolyPolygon aMask(rMaskCandidate.getMask()); 757cdf0e10cSrcweir 758cdf0e10cSrcweir if(aMask.count()) 759cdf0e10cSrcweir { 760cdf0e10cSrcweir aMask.transform(maCurrentTransformation); 761cdf0e10cSrcweir const basegfx::B2DRange aRange(basegfx::tools::getRange(aMask)); 762cdf0e10cSrcweir impBufferDevice aBufferDevice(*mpOutputDevice, aRange, true); 763cdf0e10cSrcweir 764cdf0e10cSrcweir if(aBufferDevice.isVisible()) 765cdf0e10cSrcweir { 766cdf0e10cSrcweir // remember last OutDev and set to content 767cdf0e10cSrcweir OutputDevice* pLastOutputDevice = mpOutputDevice; 768cdf0e10cSrcweir mpOutputDevice = &aBufferDevice.getContent(); 769cdf0e10cSrcweir 770cdf0e10cSrcweir // paint to it 771cdf0e10cSrcweir process(rMaskCandidate.getChildren()); 772cdf0e10cSrcweir 773cdf0e10cSrcweir // back to old OutDev 774cdf0e10cSrcweir mpOutputDevice = pLastOutputDevice; 775cdf0e10cSrcweir 776cdf0e10cSrcweir // draw mask 777cdf0e10cSrcweir if(getOptionsDrawinglayer().IsAntiAliasing()) 778cdf0e10cSrcweir { 779cdf0e10cSrcweir // with AA, use 8bit AlphaMask to get nice borders 780cdf0e10cSrcweir VirtualDevice& rTransparence = aBufferDevice.getTransparence(); 781cdf0e10cSrcweir rTransparence.SetLineColor(); 782cdf0e10cSrcweir rTransparence.SetFillColor(COL_BLACK); 783cdf0e10cSrcweir rTransparence.DrawPolyPolygon(aMask); 784cdf0e10cSrcweir 785cdf0e10cSrcweir // dump buffer to outdev 786cdf0e10cSrcweir aBufferDevice.paint(); 787cdf0e10cSrcweir } 788cdf0e10cSrcweir else 789cdf0e10cSrcweir { 790cdf0e10cSrcweir // No AA, use 1bit mask 791cdf0e10cSrcweir VirtualDevice& rMask = aBufferDevice.getMask(); 792cdf0e10cSrcweir rMask.SetLineColor(); 793cdf0e10cSrcweir rMask.SetFillColor(COL_BLACK); 794cdf0e10cSrcweir rMask.DrawPolyPolygon(aMask); 795cdf0e10cSrcweir 796cdf0e10cSrcweir // dump buffer to outdev 797cdf0e10cSrcweir aBufferDevice.paint(); 798cdf0e10cSrcweir } 799cdf0e10cSrcweir } 800cdf0e10cSrcweir } 801cdf0e10cSrcweir } 802cdf0e10cSrcweir } 803cdf0e10cSrcweir 804cdf0e10cSrcweir // modified color group. Force output to unified color. RenderModifiedColorPrimitive2D(const primitive2d::ModifiedColorPrimitive2D & rModifiedCandidate)805cdf0e10cSrcweir void VclProcessor2D::RenderModifiedColorPrimitive2D(const primitive2d::ModifiedColorPrimitive2D& rModifiedCandidate) 806cdf0e10cSrcweir { 807cdf0e10cSrcweir if(rModifiedCandidate.getChildren().hasElements()) 808cdf0e10cSrcweir { 809cdf0e10cSrcweir maBColorModifierStack.push(rModifiedCandidate.getColorModifier()); 810cdf0e10cSrcweir process(rModifiedCandidate.getChildren()); 811cdf0e10cSrcweir maBColorModifierStack.pop(); 812cdf0e10cSrcweir } 813cdf0e10cSrcweir } 814cdf0e10cSrcweir 815cdf0e10cSrcweir // unified sub-transparence. Draw to VDev first. RenderUnifiedTransparencePrimitive2D(const primitive2d::UnifiedTransparencePrimitive2D & rTransCandidate)816cdf0e10cSrcweir void VclProcessor2D::RenderUnifiedTransparencePrimitive2D(const primitive2d::UnifiedTransparencePrimitive2D& rTransCandidate) 817cdf0e10cSrcweir { 818cdf0e10cSrcweir static bool bForceToDecomposition(false); 819cdf0e10cSrcweir 820cdf0e10cSrcweir if(rTransCandidate.getChildren().hasElements()) 821cdf0e10cSrcweir { 822cdf0e10cSrcweir if(bForceToDecomposition) 823cdf0e10cSrcweir { 824cdf0e10cSrcweir // use decomposition 825cdf0e10cSrcweir process(rTransCandidate.get2DDecomposition(getViewInformation2D())); 826cdf0e10cSrcweir } 827cdf0e10cSrcweir else 828cdf0e10cSrcweir { 829cdf0e10cSrcweir if(0.0 == rTransCandidate.getTransparence()) 830cdf0e10cSrcweir { 831cdf0e10cSrcweir // no transparence used, so just use the content 832cdf0e10cSrcweir process(rTransCandidate.getChildren()); 833cdf0e10cSrcweir } 834cdf0e10cSrcweir else if(rTransCandidate.getTransparence() > 0.0 && rTransCandidate.getTransparence() < 1.0) 835cdf0e10cSrcweir { 836cdf0e10cSrcweir // transparence is in visible range 837cdf0e10cSrcweir basegfx::B2DRange aRange(primitive2d::getB2DRangeFromPrimitive2DSequence(rTransCandidate.getChildren(), getViewInformation2D())); 838cdf0e10cSrcweir aRange.transform(maCurrentTransformation); 839cdf0e10cSrcweir impBufferDevice aBufferDevice(*mpOutputDevice, aRange, true); 840cdf0e10cSrcweir 841cdf0e10cSrcweir if(aBufferDevice.isVisible()) 842cdf0e10cSrcweir { 843cdf0e10cSrcweir // remember last OutDev and set to content 844cdf0e10cSrcweir OutputDevice* pLastOutputDevice = mpOutputDevice; 845cdf0e10cSrcweir mpOutputDevice = &aBufferDevice.getContent(); 846cdf0e10cSrcweir 847cdf0e10cSrcweir // paint content to it 848cdf0e10cSrcweir process(rTransCandidate.getChildren()); 849cdf0e10cSrcweir 850cdf0e10cSrcweir // back to old OutDev 851cdf0e10cSrcweir mpOutputDevice = pLastOutputDevice; 852cdf0e10cSrcweir 853cdf0e10cSrcweir // dump buffer to outdev using given transparence 854cdf0e10cSrcweir aBufferDevice.paint(rTransCandidate.getTransparence()); 855cdf0e10cSrcweir } 856cdf0e10cSrcweir } 857cdf0e10cSrcweir } 858cdf0e10cSrcweir } 859cdf0e10cSrcweir } 860cdf0e10cSrcweir 861cdf0e10cSrcweir // sub-transparence group. Draw to VDev first. RenderTransparencePrimitive2D(const primitive2d::TransparencePrimitive2D & rTransCandidate)862cdf0e10cSrcweir void VclProcessor2D::RenderTransparencePrimitive2D(const primitive2d::TransparencePrimitive2D& rTransCandidate) 863cdf0e10cSrcweir { 864cdf0e10cSrcweir if(rTransCandidate.getChildren().hasElements()) 865cdf0e10cSrcweir { 866cdf0e10cSrcweir basegfx::B2DRange aRange(primitive2d::getB2DRangeFromPrimitive2DSequence(rTransCandidate.getChildren(), getViewInformation2D())); 867cdf0e10cSrcweir aRange.transform(maCurrentTransformation); 868cdf0e10cSrcweir impBufferDevice aBufferDevice(*mpOutputDevice, aRange, true); 869cdf0e10cSrcweir 870cdf0e10cSrcweir if(aBufferDevice.isVisible()) 871cdf0e10cSrcweir { 872cdf0e10cSrcweir // remember last OutDev and set to content 873cdf0e10cSrcweir OutputDevice* pLastOutputDevice = mpOutputDevice; 874cdf0e10cSrcweir mpOutputDevice = &aBufferDevice.getContent(); 875cdf0e10cSrcweir 876cdf0e10cSrcweir // paint content to it 877cdf0e10cSrcweir process(rTransCandidate.getChildren()); 878cdf0e10cSrcweir 879cdf0e10cSrcweir // set to mask 880cdf0e10cSrcweir mpOutputDevice = &aBufferDevice.getTransparence(); 881cdf0e10cSrcweir 882cdf0e10cSrcweir // when painting transparence masks, reset the color stack 883cdf0e10cSrcweir basegfx::BColorModifierStack aLastBColorModifierStack(maBColorModifierStack); 884cdf0e10cSrcweir maBColorModifierStack = basegfx::BColorModifierStack(); 885cdf0e10cSrcweir 886cdf0e10cSrcweir // paint mask to it (always with transparence intensities, evtl. with AA) 887cdf0e10cSrcweir process(rTransCandidate.getTransparence()); 888cdf0e10cSrcweir 889cdf0e10cSrcweir // back to old color stack 890cdf0e10cSrcweir maBColorModifierStack = aLastBColorModifierStack; 891cdf0e10cSrcweir 892cdf0e10cSrcweir // back to old OutDev 893cdf0e10cSrcweir mpOutputDevice = pLastOutputDevice; 894cdf0e10cSrcweir 895cdf0e10cSrcweir // dump buffer to outdev 896cdf0e10cSrcweir aBufferDevice.paint(); 897cdf0e10cSrcweir } 898cdf0e10cSrcweir } 899cdf0e10cSrcweir } 900cdf0e10cSrcweir 901cdf0e10cSrcweir // transform group. RenderTransformPrimitive2D(const primitive2d::TransformPrimitive2D & rTransformCandidate)902cdf0e10cSrcweir void VclProcessor2D::RenderTransformPrimitive2D(const primitive2d::TransformPrimitive2D& rTransformCandidate) 903cdf0e10cSrcweir { 904cdf0e10cSrcweir // remember current transformation and ViewInformation 905cdf0e10cSrcweir const basegfx::B2DHomMatrix aLastCurrentTransformation(maCurrentTransformation); 906cdf0e10cSrcweir const geometry::ViewInformation2D aLastViewInformation2D(getViewInformation2D()); 907cdf0e10cSrcweir 908cdf0e10cSrcweir // create new transformations for CurrentTransformation 909cdf0e10cSrcweir // and for local ViewInformation2D 910cdf0e10cSrcweir maCurrentTransformation = maCurrentTransformation * rTransformCandidate.getTransformation(); 911cdf0e10cSrcweir const geometry::ViewInformation2D aViewInformation2D( 912cdf0e10cSrcweir getViewInformation2D().getObjectTransformation() * rTransformCandidate.getTransformation(), 913cdf0e10cSrcweir getViewInformation2D().getViewTransformation(), 914cdf0e10cSrcweir getViewInformation2D().getViewport(), 915cdf0e10cSrcweir getViewInformation2D().getVisualizedPage(), 916cdf0e10cSrcweir getViewInformation2D().getViewTime(), 917cdf0e10cSrcweir getViewInformation2D().getExtendedInformationSequence()); 918cdf0e10cSrcweir updateViewInformation(aViewInformation2D); 919cdf0e10cSrcweir 920cdf0e10cSrcweir // proccess content 921cdf0e10cSrcweir process(rTransformCandidate.getChildren()); 922cdf0e10cSrcweir 923cdf0e10cSrcweir // restore transformations 924cdf0e10cSrcweir maCurrentTransformation = aLastCurrentTransformation; 925cdf0e10cSrcweir updateViewInformation(aLastViewInformation2D); 926cdf0e10cSrcweir } 927cdf0e10cSrcweir 928cdf0e10cSrcweir // new XDrawPage for ViewInformation2D RenderPagePreviewPrimitive2D(const primitive2d::PagePreviewPrimitive2D & rPagePreviewCandidate)929cdf0e10cSrcweir void VclProcessor2D::RenderPagePreviewPrimitive2D(const primitive2d::PagePreviewPrimitive2D& rPagePreviewCandidate) 930cdf0e10cSrcweir { 931cdf0e10cSrcweir // remember current transformation and ViewInformation 932cdf0e10cSrcweir const geometry::ViewInformation2D aLastViewInformation2D(getViewInformation2D()); 933cdf0e10cSrcweir 934cdf0e10cSrcweir // create new local ViewInformation2D 935cdf0e10cSrcweir const geometry::ViewInformation2D aViewInformation2D( 936cdf0e10cSrcweir getViewInformation2D().getObjectTransformation(), 937cdf0e10cSrcweir getViewInformation2D().getViewTransformation(), 938cdf0e10cSrcweir getViewInformation2D().getViewport(), 939cdf0e10cSrcweir rPagePreviewCandidate.getXDrawPage(), 940cdf0e10cSrcweir getViewInformation2D().getViewTime(), 941cdf0e10cSrcweir getViewInformation2D().getExtendedInformationSequence()); 942cdf0e10cSrcweir updateViewInformation(aViewInformation2D); 943cdf0e10cSrcweir 944cdf0e10cSrcweir // proccess decomposed content 945cdf0e10cSrcweir process(rPagePreviewCandidate.get2DDecomposition(getViewInformation2D())); 946cdf0e10cSrcweir 947cdf0e10cSrcweir // restore transformations 948cdf0e10cSrcweir updateViewInformation(aLastViewInformation2D); 949cdf0e10cSrcweir } 950cdf0e10cSrcweir 951cdf0e10cSrcweir // marker RenderMarkerArrayPrimitive2D(const primitive2d::MarkerArrayPrimitive2D & rMarkArrayCandidate)952cdf0e10cSrcweir void VclProcessor2D::RenderMarkerArrayPrimitive2D(const primitive2d::MarkerArrayPrimitive2D& rMarkArrayCandidate) 953cdf0e10cSrcweir { 954cdf0e10cSrcweir static bool bCheckCompleteMarkerDecompose(false); 955cdf0e10cSrcweir if(bCheckCompleteMarkerDecompose) 956cdf0e10cSrcweir { 957cdf0e10cSrcweir process(rMarkArrayCandidate.get2DDecomposition(getViewInformation2D())); 958cdf0e10cSrcweir return; 959cdf0e10cSrcweir } 960cdf0e10cSrcweir 961cdf0e10cSrcweir // get data 962cdf0e10cSrcweir const std::vector< basegfx::B2DPoint >& rPositions = rMarkArrayCandidate.getPositions(); 963cdf0e10cSrcweir const sal_uInt32 nCount(rPositions.size()); 964cdf0e10cSrcweir 965cdf0e10cSrcweir if(nCount && !rMarkArrayCandidate.getMarker().IsEmpty()) 966cdf0e10cSrcweir { 967cdf0e10cSrcweir // get pixel size 968cdf0e10cSrcweir const BitmapEx& rMarker(rMarkArrayCandidate.getMarker()); 969cdf0e10cSrcweir const Size aBitmapSize(rMarker.GetSizePixel()); 970cdf0e10cSrcweir 971cdf0e10cSrcweir if(aBitmapSize.Width() && aBitmapSize.Height()) 972cdf0e10cSrcweir { 973cdf0e10cSrcweir // get discrete half size 974cdf0e10cSrcweir const basegfx::B2DVector aDiscreteHalfSize( 975cdf0e10cSrcweir (aBitmapSize.getWidth() - 1.0) * 0.5, 976cdf0e10cSrcweir (aBitmapSize.getHeight() - 1.0) * 0.5); 977cdf0e10cSrcweir const bool bWasEnabled(mpOutputDevice->IsMapModeEnabled()); 978cdf0e10cSrcweir 979cdf0e10cSrcweir // do not forget evtl. moved origin in target device MapMode when 980cdf0e10cSrcweir // switching it off; it would be missing and lead to wrong positions. 981cdf0e10cSrcweir // All his could be done using logic sizes and coordinates, too, but 982cdf0e10cSrcweir // we want a 1:1 bitmap rendering here, so it's more safe and faster 983cdf0e10cSrcweir // to work with switching off MapMode usage completely. 984cdf0e10cSrcweir const Point aOrigin(mpOutputDevice->GetMapMode().GetOrigin()); 985cdf0e10cSrcweir 986cdf0e10cSrcweir mpOutputDevice->EnableMapMode(false); 987cdf0e10cSrcweir 988cdf0e10cSrcweir for(std::vector< basegfx::B2DPoint >::const_iterator aIter(rPositions.begin()); aIter != rPositions.end(); aIter++) 989cdf0e10cSrcweir { 990cdf0e10cSrcweir const basegfx::B2DPoint aDiscreteTopLeft((maCurrentTransformation * (*aIter)) - aDiscreteHalfSize); 991cdf0e10cSrcweir const Point aDiscretePoint(basegfx::fround(aDiscreteTopLeft.getX()), basegfx::fround(aDiscreteTopLeft.getY())); 992cdf0e10cSrcweir 993cdf0e10cSrcweir mpOutputDevice->DrawBitmapEx(aDiscretePoint + aOrigin, rMarker); 994cdf0e10cSrcweir } 995cdf0e10cSrcweir 996cdf0e10cSrcweir mpOutputDevice->EnableMapMode(bWasEnabled); 997cdf0e10cSrcweir } 998cdf0e10cSrcweir } 999cdf0e10cSrcweir } 1000cdf0e10cSrcweir 1001cdf0e10cSrcweir // point RenderPointArrayPrimitive2D(const primitive2d::PointArrayPrimitive2D & rPointArrayCandidate)1002cdf0e10cSrcweir void VclProcessor2D::RenderPointArrayPrimitive2D(const primitive2d::PointArrayPrimitive2D& rPointArrayCandidate) 1003cdf0e10cSrcweir { 1004cdf0e10cSrcweir const std::vector< basegfx::B2DPoint >& rPositions = rPointArrayCandidate.getPositions(); 1005cdf0e10cSrcweir const basegfx::BColor aRGBColor(maBColorModifierStack.getModifiedColor(rPointArrayCandidate.getRGBColor())); 1006cdf0e10cSrcweir const Color aVCLColor(aRGBColor); 1007cdf0e10cSrcweir 1008cdf0e10cSrcweir for(std::vector< basegfx::B2DPoint >::const_iterator aIter(rPositions.begin()); aIter != rPositions.end(); aIter++) 1009cdf0e10cSrcweir { 1010cdf0e10cSrcweir const basegfx::B2DPoint aViewPosition(maCurrentTransformation * (*aIter)); 1011cdf0e10cSrcweir const Point aPos(basegfx::fround(aViewPosition.getX()), basegfx::fround(aViewPosition.getY())); 1012cdf0e10cSrcweir 1013cdf0e10cSrcweir mpOutputDevice->DrawPixel(aPos, aVCLColor); 1014cdf0e10cSrcweir } 1015cdf0e10cSrcweir } 1016cdf0e10cSrcweir RenderPolygonStrokePrimitive2D(const primitive2d::PolygonStrokePrimitive2D & rPolygonStrokeCandidate)1017cdf0e10cSrcweir void VclProcessor2D::RenderPolygonStrokePrimitive2D(const primitive2d::PolygonStrokePrimitive2D& rPolygonStrokeCandidate) 1018cdf0e10cSrcweir { 1019cdf0e10cSrcweir // #i101491# method restructured to clearly use the DrawPolyLine 1020cdf0e10cSrcweir // calls starting from a deined line width 1021cdf0e10cSrcweir const attribute::LineAttribute& rLineAttribute = rPolygonStrokeCandidate.getLineAttribute(); 1022cdf0e10cSrcweir const double fLineWidth(rLineAttribute.getWidth()); 1023cdf0e10cSrcweir bool bDone(false); 1024cdf0e10cSrcweir 1025cdf0e10cSrcweir if(basegfx::fTools::more(fLineWidth, 0.0)) 1026cdf0e10cSrcweir { 1027cdf0e10cSrcweir const basegfx::B2DVector aDiscreteUnit(maCurrentTransformation * basegfx::B2DVector(fLineWidth, 0.0)); 1028cdf0e10cSrcweir const double fDiscreteLineWidth(aDiscreteUnit.getLength()); 1029cdf0e10cSrcweir const attribute::StrokeAttribute& rStrokeAttribute = rPolygonStrokeCandidate.getStrokeAttribute(); 1030cdf0e10cSrcweir const basegfx::BColor aHairlineColor(maBColorModifierStack.getModifiedColor(rLineAttribute.getColor())); 1031cdf0e10cSrcweir basegfx::B2DPolyPolygon aHairlinePolyPolygon; 1032cdf0e10cSrcweir 1033cdf0e10cSrcweir mpOutputDevice->SetLineColor(Color(aHairlineColor)); 1034cdf0e10cSrcweir mpOutputDevice->SetFillColor(); 1035cdf0e10cSrcweir 1036cdf0e10cSrcweir if(0.0 == rStrokeAttribute.getFullDotDashLen()) 1037cdf0e10cSrcweir { 1038cdf0e10cSrcweir // no line dashing, just copy 1039cdf0e10cSrcweir aHairlinePolyPolygon.append(rPolygonStrokeCandidate.getB2DPolygon()); 1040cdf0e10cSrcweir } 1041cdf0e10cSrcweir else 1042cdf0e10cSrcweir { 1043cdf0e10cSrcweir // else apply LineStyle 1044cdf0e10cSrcweir basegfx::tools::applyLineDashing(rPolygonStrokeCandidate.getB2DPolygon(), 1045cdf0e10cSrcweir rStrokeAttribute.getDotDashArray(), 1046cdf0e10cSrcweir &aHairlinePolyPolygon, 0, rStrokeAttribute.getFullDotDashLen()); 1047cdf0e10cSrcweir } 1048cdf0e10cSrcweir 1049cdf0e10cSrcweir const sal_uInt32 nCount(aHairlinePolyPolygon.count()); 1050cdf0e10cSrcweir 1051cdf0e10cSrcweir if(nCount) 1052cdf0e10cSrcweir { 1053cdf0e10cSrcweir const bool bAntiAliased(getOptionsDrawinglayer().IsAntiAliasing()); 10547be6ee6dSArmin Le Grand aHairlinePolyPolygon.transform(maCurrentTransformation); 1055cdf0e10cSrcweir 10567be6ee6dSArmin Le Grand if(bAntiAliased) 10577be6ee6dSArmin Le Grand { 10587be6ee6dSArmin Le Grand if(basegfx::fTools::lessOrEqual(fDiscreteLineWidth, 1.0)) 1059cdf0e10cSrcweir { 10607be6ee6dSArmin Le Grand // line in range ]0.0 .. 1.0[ 10617be6ee6dSArmin Le Grand // paint as simple hairline 10627be6ee6dSArmin Le Grand for(sal_uInt32 a(0); a < nCount; a++) 1063cdf0e10cSrcweir { 10647be6ee6dSArmin Le Grand mpOutputDevice->DrawPolyLine(aHairlinePolyPolygon.getB2DPolygon(a), 0.0); 1065cdf0e10cSrcweir } 10667be6ee6dSArmin Le Grand 10677be6ee6dSArmin Le Grand bDone = true; 10687be6ee6dSArmin Le Grand } 10697be6ee6dSArmin Le Grand else if(basegfx::fTools::lessOrEqual(fDiscreteLineWidth, 2.0)) 10707be6ee6dSArmin Le Grand { 10717be6ee6dSArmin Le Grand // line in range [1.0 .. 2.0[ 10727be6ee6dSArmin Le Grand // paint as 2x2 with dynamic line distance 10737be6ee6dSArmin Le Grand basegfx::B2DHomMatrix aMat; 10747be6ee6dSArmin Le Grand const double fDistance(fDiscreteLineWidth - 1.0); 10757be6ee6dSArmin Le Grand const double fHalfDistance(fDistance * 0.5); 10767be6ee6dSArmin Le Grand 10777be6ee6dSArmin Le Grand for(sal_uInt32 a(0); a < nCount; a++) 1078cdf0e10cSrcweir { 10797be6ee6dSArmin Le Grand basegfx::B2DPolygon aCandidate(aHairlinePolyPolygon.getB2DPolygon(a)); 10807be6ee6dSArmin Le Grand 10817be6ee6dSArmin Le Grand aMat.set(0, 2, -fHalfDistance); 10827be6ee6dSArmin Le Grand aMat.set(1, 2, -fHalfDistance); 1083cdf0e10cSrcweir aCandidate.transform(aMat); 10847be6ee6dSArmin Le Grand mpOutputDevice->DrawPolyLine(aCandidate, 0.0); 10857be6ee6dSArmin Le Grand 10867be6ee6dSArmin Le Grand aMat.set(0, 2, fDistance); 10877be6ee6dSArmin Le Grand aMat.set(1, 2, 0.0); 1088cdf0e10cSrcweir aCandidate.transform(aMat); 10897be6ee6dSArmin Le Grand mpOutputDevice->DrawPolyLine(aCandidate, 0.0); 10907be6ee6dSArmin Le Grand 10917be6ee6dSArmin Le Grand aMat.set(0, 2, 0.0); 10927be6ee6dSArmin Le Grand aMat.set(1, 2, fDistance); 1093cdf0e10cSrcweir aCandidate.transform(aMat); 10947be6ee6dSArmin Le Grand mpOutputDevice->DrawPolyLine(aCandidate, 0.0); 10957be6ee6dSArmin Le Grand 10967be6ee6dSArmin Le Grand aMat.set(0, 2, -fDistance); 10977be6ee6dSArmin Le Grand aMat.set(1, 2, 0.0); 1098cdf0e10cSrcweir aCandidate.transform(aMat); 10997be6ee6dSArmin Le Grand mpOutputDevice->DrawPolyLine(aCandidate, 0.0); 1100cdf0e10cSrcweir } 11017be6ee6dSArmin Le Grand 11027be6ee6dSArmin Le Grand bDone = true; 11037be6ee6dSArmin Le Grand } 11047be6ee6dSArmin Le Grand else if(basegfx::fTools::lessOrEqual(fDiscreteLineWidth, 3.0)) 11057be6ee6dSArmin Le Grand { 11067be6ee6dSArmin Le Grand // line in range [2.0 .. 3.0] 11077be6ee6dSArmin Le Grand // paint as cross in a 3x3 with dynamic line distance 11087be6ee6dSArmin Le Grand basegfx::B2DHomMatrix aMat; 11097be6ee6dSArmin Le Grand const double fDistance((fDiscreteLineWidth - 1.0) * 0.5); 11107be6ee6dSArmin Le Grand 11117be6ee6dSArmin Le Grand for(sal_uInt32 a(0); a < nCount; a++) 1112cdf0e10cSrcweir { 11137be6ee6dSArmin Le Grand basegfx::B2DPolygon aCandidate(aHairlinePolyPolygon.getB2DPolygon(a)); 1114cdf0e10cSrcweir 1115cdf0e10cSrcweir mpOutputDevice->DrawPolyLine(aCandidate, 0.0); 1116cdf0e10cSrcweir 1117cdf0e10cSrcweir aMat.set(0, 2, -fDistance); 11187be6ee6dSArmin Le Grand aMat.set(1, 2, 0.0); 1119cdf0e10cSrcweir aCandidate.transform(aMat); 11207be6ee6dSArmin Le Grand mpOutputDevice->DrawPolyLine(aCandidate, 0.0); 11217be6ee6dSArmin Le Grand 1122cdf0e10cSrcweir aMat.set(0, 2, fDistance); 11237be6ee6dSArmin Le Grand aMat.set(1, 2, -fDistance); 1124cdf0e10cSrcweir aCandidate.transform(aMat); 11257be6ee6dSArmin Le Grand mpOutputDevice->DrawPolyLine(aCandidate, 0.0); 11267be6ee6dSArmin Le Grand 1127cdf0e10cSrcweir aMat.set(0, 2, fDistance); 11287be6ee6dSArmin Le Grand aMat.set(1, 2, fDistance); 1129cdf0e10cSrcweir aCandidate.transform(aMat); 11307be6ee6dSArmin Le Grand mpOutputDevice->DrawPolyLine(aCandidate, 0.0); 11317be6ee6dSArmin Le Grand 1132cdf0e10cSrcweir aMat.set(0, 2, -fDistance); 11337be6ee6dSArmin Le Grand aMat.set(1, 2, fDistance); 1134cdf0e10cSrcweir aCandidate.transform(aMat); 11357be6ee6dSArmin Le Grand mpOutputDevice->DrawPolyLine(aCandidate, 0.0); 1136cdf0e10cSrcweir } 11377be6ee6dSArmin Le Grand 11387be6ee6dSArmin Le Grand bDone = true; 1139cdf0e10cSrcweir } 1140cdf0e10cSrcweir else 1141cdf0e10cSrcweir { 11427be6ee6dSArmin Le Grand // #i101491# line width above 3.0 11437be6ee6dSArmin Le Grand } 11447be6ee6dSArmin Le Grand } 11457be6ee6dSArmin Le Grand else 11467be6ee6dSArmin Le Grand { 11477be6ee6dSArmin Le Grand if(basegfx::fTools::lessOrEqual(fDiscreteLineWidth, 1.5)) 11487be6ee6dSArmin Le Grand { 11497be6ee6dSArmin Le Grand // line width below 1.5, draw the basic hairline polygon 11507be6ee6dSArmin Le Grand for(sal_uInt32 a(0); a < nCount; a++) 1151cdf0e10cSrcweir { 11527be6ee6dSArmin Le Grand mpOutputDevice->DrawPolyLine(aHairlinePolyPolygon.getB2DPolygon(a), 0.0); 1153cdf0e10cSrcweir } 1154cdf0e10cSrcweir 11557be6ee6dSArmin Le Grand bDone = true; 11567be6ee6dSArmin Le Grand } 11577be6ee6dSArmin Le Grand else if(basegfx::fTools::lessOrEqual(fDiscreteLineWidth, 2.5)) 11587be6ee6dSArmin Le Grand { 11597be6ee6dSArmin Le Grand // line width is in range ]1.5 .. 2.5], use four hairlines 11607be6ee6dSArmin Le Grand // drawn in a square 11617be6ee6dSArmin Le Grand for(sal_uInt32 a(0); a < nCount; a++) 11627be6ee6dSArmin Le Grand { 11637be6ee6dSArmin Le Grand basegfx::B2DPolygon aCandidate(aHairlinePolyPolygon.getB2DPolygon(a)); 11647be6ee6dSArmin Le Grand basegfx::B2DHomMatrix aMat; 1165cdf0e10cSrcweir 11667be6ee6dSArmin Le Grand mpOutputDevice->DrawPolyLine(aCandidate, 0.0); 11677be6ee6dSArmin Le Grand 11687be6ee6dSArmin Le Grand aMat.set(0, 2, 1.0); 11697be6ee6dSArmin Le Grand aMat.set(1, 2, 0.0); 11707be6ee6dSArmin Le Grand aCandidate.transform(aMat); 11717be6ee6dSArmin Le Grand 11727be6ee6dSArmin Le Grand mpOutputDevice->DrawPolyLine(aCandidate, 0.0); 11737be6ee6dSArmin Le Grand 11747be6ee6dSArmin Le Grand aMat.set(0, 2, 0.0); 11757be6ee6dSArmin Le Grand aMat.set(1, 2, 1.0); 11767be6ee6dSArmin Le Grand aCandidate.transform(aMat); 11777be6ee6dSArmin Le Grand 11787be6ee6dSArmin Le Grand mpOutputDevice->DrawPolyLine(aCandidate, 0.0); 11797be6ee6dSArmin Le Grand 11807be6ee6dSArmin Le Grand aMat.set(0, 2, -1.0); 11817be6ee6dSArmin Le Grand aMat.set(1, 2, 0.0); 11827be6ee6dSArmin Le Grand aCandidate.transform(aMat); 11837be6ee6dSArmin Le Grand 11847be6ee6dSArmin Le Grand mpOutputDevice->DrawPolyLine(aCandidate, 0.0); 11857be6ee6dSArmin Le Grand } 1186cdf0e10cSrcweir 11877be6ee6dSArmin Le Grand bDone = true; 11887be6ee6dSArmin Le Grand } 11897be6ee6dSArmin Le Grand else 11907be6ee6dSArmin Le Grand { 11917be6ee6dSArmin Le Grand // #i101491# line width is above 2.5 11927be6ee6dSArmin Le Grand } 11937be6ee6dSArmin Le Grand } 1194cdf0e10cSrcweir 11957be6ee6dSArmin Le Grand if(!bDone && rPolygonStrokeCandidate.getB2DPolygon().count() > 1000) 11967be6ee6dSArmin Le Grand { 11977be6ee6dSArmin Le Grand // #i101491# If the polygon complexity uses more than a given amount, do 11987be6ee6dSArmin Le Grand // use OuputDevice::DrawPolyLine directly; this will avoid buffering all 11997be6ee6dSArmin Le Grand // decompositions in primtives (memory) and fallback to old line painting 12007be6ee6dSArmin Le Grand // for very complex polygons, too 12017be6ee6dSArmin Le Grand for(sal_uInt32 a(0); a < nCount; a++) 12027be6ee6dSArmin Le Grand { 12037be6ee6dSArmin Le Grand mpOutputDevice->DrawPolyLine( 12047be6ee6dSArmin Le Grand aHairlinePolyPolygon.getB2DPolygon(a), 12057be6ee6dSArmin Le Grand fDiscreteLineWidth, 12067be6ee6dSArmin Le Grand rLineAttribute.getLineJoin(), 12077be6ee6dSArmin Le Grand rLineAttribute.getLineCap()); 1208cdf0e10cSrcweir } 1209cdf0e10cSrcweir 12107be6ee6dSArmin Le Grand bDone = true; 1211cdf0e10cSrcweir } 1212cdf0e10cSrcweir } 1213cdf0e10cSrcweir } 1214cdf0e10cSrcweir 1215cdf0e10cSrcweir if(!bDone) 1216cdf0e10cSrcweir { 1217cdf0e10cSrcweir // remeber that we enter a PolygonStrokePrimitive2D decomposition, 1218cdf0e10cSrcweir // used for AA thick line drawing 1219cdf0e10cSrcweir mnPolygonStrokePrimitive2D++; 1220cdf0e10cSrcweir 1221cdf0e10cSrcweir // line width is big enough for standard filled polygon visualisation or zero 1222cdf0e10cSrcweir process(rPolygonStrokeCandidate.get2DDecomposition(getViewInformation2D())); 1223cdf0e10cSrcweir 1224cdf0e10cSrcweir // leave PolygonStrokePrimitive2D 1225cdf0e10cSrcweir mnPolygonStrokePrimitive2D--; 1226cdf0e10cSrcweir } 1227cdf0e10cSrcweir } 1228cdf0e10cSrcweir RenderEpsPrimitive2D(const primitive2d::EpsPrimitive2D & rEpsPrimitive2D)1229cdf0e10cSrcweir void VclProcessor2D::RenderEpsPrimitive2D(const primitive2d::EpsPrimitive2D& rEpsPrimitive2D) 1230cdf0e10cSrcweir { 1231cdf0e10cSrcweir // The new decomposition of Metafiles made it necessary to add an Eps 1232cdf0e10cSrcweir // primitive to handle embedded Eps data. On some devices, this can be 1233cdf0e10cSrcweir // painted directly (mac, printer). 1234cdf0e10cSrcweir // To be able to handle the replacement correctly, i need to handle it myself 1235cdf0e10cSrcweir // since DrawEPS will not be able e.g. to rotate the replacement. To be able 1236cdf0e10cSrcweir // to do that, i added a boolean return to OutputDevice::DrawEPS(..) 1237cdf0e10cSrcweir // to know when EPS was handled directly already. 1238cdf0e10cSrcweir basegfx::B2DRange aRange(0.0, 0.0, 1.0, 1.0); 1239cdf0e10cSrcweir aRange.transform(maCurrentTransformation * rEpsPrimitive2D.getEpsTransform()); 1240cdf0e10cSrcweir 1241cdf0e10cSrcweir if(!aRange.isEmpty()) 1242cdf0e10cSrcweir { 1243cdf0e10cSrcweir const Rectangle aRectangle( 1244cdf0e10cSrcweir (sal_Int32)floor(aRange.getMinX()), (sal_Int32)floor(aRange.getMinY()), 1245cdf0e10cSrcweir (sal_Int32)ceil(aRange.getMaxX()), (sal_Int32)ceil(aRange.getMaxY())); 1246cdf0e10cSrcweir 1247cdf0e10cSrcweir if(!aRectangle.IsEmpty()) 1248cdf0e10cSrcweir { 1249cdf0e10cSrcweir // try to paint EPS directly without fallback visualisation 1250cdf0e10cSrcweir const bool bEPSPaintedDirectly(mpOutputDevice->DrawEPS( 1251cdf0e10cSrcweir aRectangle.TopLeft(), 1252cdf0e10cSrcweir aRectangle.GetSize(), 1253cdf0e10cSrcweir rEpsPrimitive2D.getGfxLink(), 1254cdf0e10cSrcweir 0)); 1255cdf0e10cSrcweir 1256cdf0e10cSrcweir if(!bEPSPaintedDirectly) 1257cdf0e10cSrcweir { 1258cdf0e10cSrcweir // use the decomposition which will correctly handle the 1259cdf0e10cSrcweir // fallback visualisation using full transformation (e.g. rotation) 1260cdf0e10cSrcweir process(rEpsPrimitive2D.get2DDecomposition(getViewInformation2D())); 1261cdf0e10cSrcweir } 1262cdf0e10cSrcweir } 1263cdf0e10cSrcweir } 1264cdf0e10cSrcweir } 1265cdf0e10cSrcweir RenderSvgLinearAtomPrimitive2D(const primitive2d::SvgLinearAtomPrimitive2D & rCandidate)126639551d71SArmin Le Grand void VclProcessor2D::RenderSvgLinearAtomPrimitive2D(const primitive2d::SvgLinearAtomPrimitive2D& rCandidate) 126739551d71SArmin Le Grand { 126839551d71SArmin Le Grand const double fDelta(rCandidate.getOffsetB() - rCandidate.getOffsetA()); 126939551d71SArmin Le Grand 127039551d71SArmin Le Grand if(basegfx::fTools::more(fDelta, 0.0)) 127139551d71SArmin Le Grand { 127239551d71SArmin Le Grand const basegfx::BColor aColorA(maBColorModifierStack.getModifiedColor(rCandidate.getColorA())); 127339551d71SArmin Le Grand const basegfx::BColor aColorB(maBColorModifierStack.getModifiedColor(rCandidate.getColorB())); 1274895ed544SArmin Le Grand 1275895ed544SArmin Le Grand // calculate discrete unit in WorldCoordinates; use diagonal (1.0, 1.0) and divide by sqrt(2) 12763d844549SArmin Le Grand const basegfx::B2DVector aDiscreteVector(getViewInformation2D().getInverseObjectToViewTransformation() * basegfx::B2DVector(1.0, 1.0)); 1277895ed544SArmin Le Grand const double fDiscreteUnit(aDiscreteVector.getLength() * (1.0 / 1.414213562373)); 127839551d71SArmin Le Grand 127939551d71SArmin Le Grand // use color distance and discrete lengths to calculate step count 128039551d71SArmin Le Grand const sal_uInt32 nSteps(calculateStepsForSvgGradient(aColorA, aColorB, fDelta, fDiscreteUnit)); 128139551d71SArmin Le Grand 1282025b0597SArmin Le Grand // switch off line painting 1283025b0597SArmin Le Grand mpOutputDevice->SetLineColor(); 1284025b0597SArmin Le Grand 1285025b0597SArmin Le Grand // prepare polygon in needed width at start position (with discrete overlap) 128639551d71SArmin Le Grand const basegfx::B2DPolygon aPolygon( 128739551d71SArmin Le Grand basegfx::tools::createPolygonFromRect( 128839551d71SArmin Le Grand basegfx::B2DRange( 128939551d71SArmin Le Grand rCandidate.getOffsetA() - fDiscreteUnit, 129039551d71SArmin Le Grand 0.0, 1291025b0597SArmin Le Grand rCandidate.getOffsetA() + (fDelta / nSteps) + fDiscreteUnit, 129239551d71SArmin Le Grand 1.0))); 129339551d71SArmin Le Grand 1294025b0597SArmin Le Grand 1295025b0597SArmin Le Grand // prepare loop ([0.0 .. 1.0[) 1296025b0597SArmin Le Grand double fUnitScale(0.0); 1297025b0597SArmin Le Grand const double fUnitStep(1.0 / nSteps); 129839551d71SArmin Le Grand 129939551d71SArmin Le Grand // loop and paint 1300025b0597SArmin Le Grand for(sal_uInt32 a(0); a < nSteps; a++, fUnitScale += fUnitStep) 130139551d71SArmin Le Grand { 130239551d71SArmin Le Grand basegfx::B2DPolygon aNew(aPolygon); 130339551d71SArmin Le Grand 1304025b0597SArmin Le Grand aNew.transform(maCurrentTransformation * basegfx::tools::createTranslateB2DHomMatrix(fDelta * fUnitScale, 0.0)); 1305025b0597SArmin Le Grand mpOutputDevice->SetFillColor(Color(basegfx::interpolate(aColorA, aColorB, fUnitScale))); 130639551d71SArmin Le Grand mpOutputDevice->DrawPolyPolygon(basegfx::B2DPolyPolygon(aNew)); 130739551d71SArmin Le Grand } 130839551d71SArmin Le Grand } 130939551d71SArmin Le Grand } 131039551d71SArmin Le Grand RenderSvgRadialAtomPrimitive2D(const primitive2d::SvgRadialAtomPrimitive2D & rCandidate)131139551d71SArmin Le Grand void VclProcessor2D::RenderSvgRadialAtomPrimitive2D(const primitive2d::SvgRadialAtomPrimitive2D& rCandidate) 131239551d71SArmin Le Grand { 131339551d71SArmin Le Grand const double fDeltaScale(rCandidate.getScaleB() - rCandidate.getScaleA()); 131439551d71SArmin Le Grand 131539551d71SArmin Le Grand if(basegfx::fTools::more(fDeltaScale, 0.0)) 131639551d71SArmin Le Grand { 131739551d71SArmin Le Grand const basegfx::BColor aColorA(maBColorModifierStack.getModifiedColor(rCandidate.getColorA())); 131839551d71SArmin Le Grand const basegfx::BColor aColorB(maBColorModifierStack.getModifiedColor(rCandidate.getColorB())); 1319895ed544SArmin Le Grand 1320895ed544SArmin Le Grand // calculate discrete unit in WorldCoordinates; use diagonal (1.0, 1.0) and divide by sqrt(2) 13213d844549SArmin Le Grand const basegfx::B2DVector aDiscreteVector(getViewInformation2D().getInverseObjectToViewTransformation() * basegfx::B2DVector(1.0, 1.0)); 1322895ed544SArmin Le Grand const double fDiscreteUnit(aDiscreteVector.getLength() * (1.0 / 1.414213562373)); 132339551d71SArmin Le Grand 132439551d71SArmin Le Grand // use color distance and discrete lengths to calculate step count 132539551d71SArmin Le Grand const sal_uInt32 nSteps(calculateStepsForSvgGradient(aColorA, aColorB, fDeltaScale, fDiscreteUnit)); 132639551d71SArmin Le Grand 132739551d71SArmin Le Grand // switch off line painting 132839551d71SArmin Le Grand mpOutputDevice->SetLineColor(); 132939551d71SArmin Le Grand 1330025b0597SArmin Le Grand // prepare loop ([0.0 .. 1.0[, full polygons, no polypolygons with holes) 1331025b0597SArmin Le Grand double fUnitScale(0.0); 1332025b0597SArmin Le Grand const double fUnitStep(1.0 / nSteps); 133339551d71SArmin Le Grand 1334025b0597SArmin Le Grand for(sal_uInt32 a(0); a < nSteps; a++, fUnitScale += fUnitStep) 133539551d71SArmin Le Grand { 133639551d71SArmin Le Grand basegfx::B2DHomMatrix aTransform; 1337025b0597SArmin Le Grand const double fEndScale(rCandidate.getScaleB() - (fDeltaScale * fUnitScale)); 133839551d71SArmin Le Grand 133939551d71SArmin Le Grand if(rCandidate.isTranslateSet()) 134039551d71SArmin Le Grand { 134139551d71SArmin Le Grand const basegfx::B2DVector aTranslate( 134239551d71SArmin Le Grand basegfx::interpolate( 134339551d71SArmin Le Grand rCandidate.getTranslateB(), 1344025b0597SArmin Le Grand rCandidate.getTranslateA(), 134539551d71SArmin Le Grand fUnitScale)); 134639551d71SArmin Le Grand 134739551d71SArmin Le Grand aTransform = basegfx::tools::createScaleTranslateB2DHomMatrix( 134839551d71SArmin Le Grand fEndScale, 134939551d71SArmin Le Grand fEndScale, 135039551d71SArmin Le Grand aTranslate.getX(), 135139551d71SArmin Le Grand aTranslate.getY()); 135239551d71SArmin Le Grand } 135339551d71SArmin Le Grand else 135439551d71SArmin Le Grand { 135539551d71SArmin Le Grand aTransform = basegfx::tools::createScaleB2DHomMatrix( 135639551d71SArmin Le Grand fEndScale, 135739551d71SArmin Le Grand fEndScale); 135839551d71SArmin Le Grand } 135939551d71SArmin Le Grand 136039551d71SArmin Le Grand basegfx::B2DPolygon aNew(basegfx::tools::createPolygonFromUnitCircle()); 136139551d71SArmin Le Grand 136239551d71SArmin Le Grand aNew.transform(maCurrentTransformation * aTransform); 1363025b0597SArmin Le Grand mpOutputDevice->SetFillColor(Color(basegfx::interpolate(aColorB, aColorA, fUnitScale))); 136439551d71SArmin Le Grand mpOutputDevice->DrawPolyPolygon(basegfx::B2DPolyPolygon(aNew)); 136539551d71SArmin Le Grand } 136639551d71SArmin Le Grand } 136739551d71SArmin Le Grand } 136839551d71SArmin Le Grand adaptLineToFillDrawMode() const1369cdf0e10cSrcweir void VclProcessor2D::adaptLineToFillDrawMode() const 1370cdf0e10cSrcweir { 1371cdf0e10cSrcweir const sal_uInt32 nOriginalDrawMode(mpOutputDevice->GetDrawMode()); 1372cdf0e10cSrcweir 1373cdf0e10cSrcweir if(nOriginalDrawMode & (DRAWMODE_BLACKLINE|DRAWMODE_GRAYLINE|DRAWMODE_GHOSTEDLINE|DRAWMODE_WHITELINE|DRAWMODE_SETTINGSLINE)) 1374cdf0e10cSrcweir { 1375cdf0e10cSrcweir sal_uInt32 nAdaptedDrawMode(nOriginalDrawMode); 1376cdf0e10cSrcweir 1377cdf0e10cSrcweir if(nOriginalDrawMode & DRAWMODE_BLACKLINE) 1378cdf0e10cSrcweir { 1379cdf0e10cSrcweir nAdaptedDrawMode |= DRAWMODE_BLACKFILL; 1380cdf0e10cSrcweir } 1381cdf0e10cSrcweir else 1382cdf0e10cSrcweir { 1383cdf0e10cSrcweir nAdaptedDrawMode &= ~DRAWMODE_BLACKFILL; 1384cdf0e10cSrcweir } 1385cdf0e10cSrcweir 1386cdf0e10cSrcweir if(nOriginalDrawMode & DRAWMODE_GRAYLINE) 1387cdf0e10cSrcweir { 1388cdf0e10cSrcweir nAdaptedDrawMode |= DRAWMODE_GRAYFILL; 1389cdf0e10cSrcweir } 1390cdf0e10cSrcweir else 1391cdf0e10cSrcweir { 1392cdf0e10cSrcweir nAdaptedDrawMode &= ~DRAWMODE_GRAYFILL; 1393cdf0e10cSrcweir } 1394cdf0e10cSrcweir 1395cdf0e10cSrcweir if(nOriginalDrawMode & DRAWMODE_GHOSTEDLINE) 1396cdf0e10cSrcweir { 1397cdf0e10cSrcweir nAdaptedDrawMode |= DRAWMODE_GHOSTEDFILL; 1398cdf0e10cSrcweir } 1399cdf0e10cSrcweir else 1400cdf0e10cSrcweir { 1401cdf0e10cSrcweir nAdaptedDrawMode &= ~DRAWMODE_GHOSTEDFILL; 1402cdf0e10cSrcweir } 1403cdf0e10cSrcweir 1404cdf0e10cSrcweir if(nOriginalDrawMode & DRAWMODE_WHITELINE) 1405cdf0e10cSrcweir { 1406cdf0e10cSrcweir nAdaptedDrawMode |= DRAWMODE_WHITEFILL; 1407cdf0e10cSrcweir } 1408cdf0e10cSrcweir else 1409cdf0e10cSrcweir { 1410cdf0e10cSrcweir nAdaptedDrawMode &= ~DRAWMODE_WHITEFILL; 1411cdf0e10cSrcweir } 1412cdf0e10cSrcweir 1413cdf0e10cSrcweir if(nOriginalDrawMode & DRAWMODE_SETTINGSLINE) 1414cdf0e10cSrcweir { 1415cdf0e10cSrcweir nAdaptedDrawMode |= DRAWMODE_SETTINGSFILL; 1416cdf0e10cSrcweir } 1417cdf0e10cSrcweir else 1418cdf0e10cSrcweir { 1419cdf0e10cSrcweir nAdaptedDrawMode &= ~DRAWMODE_SETTINGSFILL; 1420cdf0e10cSrcweir } 1421cdf0e10cSrcweir 1422cdf0e10cSrcweir mpOutputDevice->SetDrawMode(nAdaptedDrawMode); 1423cdf0e10cSrcweir } 1424cdf0e10cSrcweir } 1425cdf0e10cSrcweir adaptTextToFillDrawMode() const1426cdf0e10cSrcweir void VclProcessor2D::adaptTextToFillDrawMode() const 1427cdf0e10cSrcweir { 1428cdf0e10cSrcweir const sal_uInt32 nOriginalDrawMode(mpOutputDevice->GetDrawMode()); 1429cdf0e10cSrcweir if(nOriginalDrawMode & (DRAWMODE_BLACKTEXT|DRAWMODE_GRAYTEXT|DRAWMODE_GHOSTEDTEXT|DRAWMODE_WHITETEXT|DRAWMODE_SETTINGSTEXT)) 1430cdf0e10cSrcweir { 1431cdf0e10cSrcweir sal_uInt32 nAdaptedDrawMode(nOriginalDrawMode); 1432cdf0e10cSrcweir 1433cdf0e10cSrcweir if(nOriginalDrawMode & DRAWMODE_BLACKTEXT) 1434cdf0e10cSrcweir { 1435cdf0e10cSrcweir nAdaptedDrawMode |= DRAWMODE_BLACKFILL; 1436cdf0e10cSrcweir } 1437cdf0e10cSrcweir else 1438cdf0e10cSrcweir { 1439cdf0e10cSrcweir nAdaptedDrawMode &= ~DRAWMODE_BLACKFILL; 1440cdf0e10cSrcweir } 1441cdf0e10cSrcweir 1442cdf0e10cSrcweir if(nOriginalDrawMode & DRAWMODE_GRAYTEXT) 1443cdf0e10cSrcweir { 1444cdf0e10cSrcweir nAdaptedDrawMode |= DRAWMODE_GRAYFILL; 1445cdf0e10cSrcweir } 1446cdf0e10cSrcweir else 1447cdf0e10cSrcweir { 1448cdf0e10cSrcweir nAdaptedDrawMode &= ~DRAWMODE_GRAYFILL; 1449cdf0e10cSrcweir } 1450cdf0e10cSrcweir 1451cdf0e10cSrcweir if(nOriginalDrawMode & DRAWMODE_GHOSTEDTEXT) 1452cdf0e10cSrcweir { 1453cdf0e10cSrcweir nAdaptedDrawMode |= DRAWMODE_GHOSTEDFILL; 1454cdf0e10cSrcweir } 1455cdf0e10cSrcweir else 1456cdf0e10cSrcweir { 1457cdf0e10cSrcweir nAdaptedDrawMode &= ~DRAWMODE_GHOSTEDFILL; 1458cdf0e10cSrcweir } 1459cdf0e10cSrcweir 1460cdf0e10cSrcweir if(nOriginalDrawMode & DRAWMODE_WHITETEXT) 1461cdf0e10cSrcweir { 1462cdf0e10cSrcweir nAdaptedDrawMode |= DRAWMODE_WHITEFILL; 1463cdf0e10cSrcweir } 1464cdf0e10cSrcweir else 1465cdf0e10cSrcweir { 1466cdf0e10cSrcweir nAdaptedDrawMode &= ~DRAWMODE_WHITEFILL; 1467cdf0e10cSrcweir } 1468cdf0e10cSrcweir 1469cdf0e10cSrcweir if(nOriginalDrawMode & DRAWMODE_SETTINGSTEXT) 1470cdf0e10cSrcweir { 1471cdf0e10cSrcweir nAdaptedDrawMode |= DRAWMODE_SETTINGSFILL; 1472cdf0e10cSrcweir } 1473cdf0e10cSrcweir else 1474cdf0e10cSrcweir { 1475cdf0e10cSrcweir nAdaptedDrawMode &= ~DRAWMODE_SETTINGSFILL; 1476cdf0e10cSrcweir } 1477cdf0e10cSrcweir 1478cdf0e10cSrcweir mpOutputDevice->SetDrawMode(nAdaptedDrawMode); 1479cdf0e10cSrcweir } 1480cdf0e10cSrcweir } 1481cdf0e10cSrcweir 1482cdf0e10cSrcweir ////////////////////////////////////////////////////////////////////////////// 1483cdf0e10cSrcweir // process support 1484cdf0e10cSrcweir VclProcessor2D(const geometry::ViewInformation2D & rViewInformation,OutputDevice & rOutDev)1485cdf0e10cSrcweir VclProcessor2D::VclProcessor2D( 1486cdf0e10cSrcweir const geometry::ViewInformation2D& rViewInformation, 1487cdf0e10cSrcweir OutputDevice& rOutDev) 1488cdf0e10cSrcweir : BaseProcessor2D(rViewInformation), 1489cdf0e10cSrcweir mpOutputDevice(&rOutDev), 1490cdf0e10cSrcweir maBColorModifierStack(), 1491cdf0e10cSrcweir maCurrentTransformation(), 1492cdf0e10cSrcweir maDrawinglayerOpt(), 1493cdf0e10cSrcweir mnPolygonStrokePrimitive2D(0) 1494cdf0e10cSrcweir { 1495cdf0e10cSrcweir // set digit language, derived from SvtCTLOptions to have the correct 1496cdf0e10cSrcweir // number display for arabic/hindi numerals 1497cdf0e10cSrcweir const SvtCTLOptions aSvtCTLOptions; 1498cdf0e10cSrcweir LanguageType eLang(LANGUAGE_SYSTEM); 1499cdf0e10cSrcweir 1500cdf0e10cSrcweir if(SvtCTLOptions::NUMERALS_HINDI == aSvtCTLOptions.GetCTLTextNumerals()) 1501cdf0e10cSrcweir { 1502cdf0e10cSrcweir eLang = LANGUAGE_ARABIC_SAUDI_ARABIA; 1503cdf0e10cSrcweir } 1504cdf0e10cSrcweir else if(SvtCTLOptions::NUMERALS_ARABIC == aSvtCTLOptions.GetCTLTextNumerals()) 1505cdf0e10cSrcweir { 1506cdf0e10cSrcweir eLang = LANGUAGE_ENGLISH; 1507cdf0e10cSrcweir } 1508cdf0e10cSrcweir else 1509cdf0e10cSrcweir { 1510cdf0e10cSrcweir eLang = (LanguageType)Application::GetSettings().GetLanguage(); 1511cdf0e10cSrcweir } 1512cdf0e10cSrcweir 1513cdf0e10cSrcweir rOutDev.SetDigitLanguage(eLang); 1514cdf0e10cSrcweir } 1515cdf0e10cSrcweir ~VclProcessor2D()1516cdf0e10cSrcweir VclProcessor2D::~VclProcessor2D() 1517cdf0e10cSrcweir { 1518cdf0e10cSrcweir } 1519cdf0e10cSrcweir } // end of namespace processor2d 1520cdf0e10cSrcweir } // end of namespace drawinglayer 1521cdf0e10cSrcweir 1522cdf0e10cSrcweir ////////////////////////////////////////////////////////////////////////////// 1523cdf0e10cSrcweir // eof 1524