| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_drawinglayer.hxx" |
| |
| #include <drawinglayer/processor2d/vclpixelprocessor2d.hxx> |
| #include <vcl/outdev.hxx> |
| #include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx> |
| #include <drawinglayer/primitive2d/textprimitive2d.hxx> |
| #include <drawinglayer/primitive2d/polypolygonprimitive2d.hxx> |
| #include <drawinglayer/primitive2d/polygonprimitive2d.hxx> |
| #include <drawinglayer/primitive2d/bitmapprimitive2d.hxx> |
| #include <drawinglayer/primitive2d/fillbitmapprimitive2d.hxx> |
| #include <drawinglayer/primitive2d/metafileprimitive2d.hxx> |
| #include <drawinglayer/primitive2d/maskprimitive2d.hxx> |
| #include <drawinglayer/primitive2d/modifiedcolorprimitive2d.hxx> |
| #include <drawinglayer/primitive2d/transparenceprimitive2d.hxx> |
| #include <drawinglayer/primitive2d/transformprimitive2d.hxx> |
| #include <drawinglayer/primitive2d/markerarrayprimitive2d.hxx> |
| #include <drawinglayer/primitive2d/pointarrayprimitive2d.hxx> |
| #include <drawinglayer/primitive2d/wrongspellprimitive2d.hxx> |
| #include <drawinglayer/primitive2d/controlprimitive2d.hxx> |
| #include <com/sun/star/awt/XWindow2.hpp> |
| #include <drawinglayer/primitive2d/unifiedtransparenceprimitive2d.hxx> |
| #include <drawinglayer/primitive2d/pagepreviewprimitive2d.hxx> |
| #include <helperwrongspellrenderer.hxx> |
| #include <drawinglayer/primitive2d/fillhatchprimitive2d.hxx> |
| #include <basegfx/polygon/b2dpolygontools.hxx> |
| #include <vcl/hatch.hxx> |
| #include <tools/diagnose_ex.h> |
| #include <com/sun/star/awt/PosSize.hpp> |
| #include <drawinglayer/primitive2d/invertprimitive2d.hxx> |
| #include <cstdio> |
| #include <drawinglayer/primitive2d/backgroundcolorprimitive2d.hxx> |
| #include <basegfx/matrix/b2dhommatrixtools.hxx> |
| #include <drawinglayer/primitive2d/epsprimitive2d.hxx> |
| #include <drawinglayer/primitive2d/svggradientprimitive2d.hxx> |
| #include <toolkit/helper/vclunohelper.hxx> |
| #include <vcl/window.hxx> |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| using namespace com::sun::star; |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| namespace drawinglayer |
| { |
| namespace processor2d |
| { |
| VclPixelProcessor2D::VclPixelProcessor2D(const geometry::ViewInformation2D& rViewInformation, OutputDevice& rOutDev) |
| : VclProcessor2D(rViewInformation, rOutDev) |
| { |
| // prepare maCurrentTransformation matrix with viewTransformation to target directly to pixels |
| maCurrentTransformation = rViewInformation.getObjectToViewTransformation(); |
| |
| // prepare output directly to pixels |
| mpOutputDevice->Push(PUSH_MAPMODE); |
| mpOutputDevice->SetMapMode(); |
| |
| // react on AntiAliasing settings |
| if(getOptionsDrawinglayer().IsAntiAliasing()) |
| { |
| mpOutputDevice->SetAntialiasing(mpOutputDevice->GetAntialiasing() | ANTIALIASING_ENABLE_B2DDRAW); |
| } |
| else |
| { |
| mpOutputDevice->SetAntialiasing(mpOutputDevice->GetAntialiasing() & ~ANTIALIASING_ENABLE_B2DDRAW); |
| } |
| } |
| |
| VclPixelProcessor2D::~VclPixelProcessor2D() |
| { |
| // restore MapMode |
| mpOutputDevice->Pop(); |
| |
| // restore AntiAliasing |
| mpOutputDevice->SetAntialiasing(mpOutputDevice->GetAntialiasing() & ~ANTIALIASING_ENABLE_B2DDRAW); |
| } |
| |
| void VclPixelProcessor2D::processBasePrimitive2D(const primitive2d::BasePrimitive2D& rCandidate) |
| { |
| switch(rCandidate.getPrimitive2DID()) |
| { |
| case PRIMITIVE2D_ID_WRONGSPELLPRIMITIVE2D : |
| { |
| // directdraw of wrong spell primitive; added test possibility to check wrong spell decompose |
| static bool bHandleWrongSpellDirectly(true); |
| |
| if(bHandleWrongSpellDirectly) |
| { |
| const primitive2d::WrongSpellPrimitive2D& rWrongSpellPrimitive = static_cast< const primitive2d::WrongSpellPrimitive2D& >(rCandidate); |
| |
| if(!renderWrongSpellPrimitive2D( |
| rWrongSpellPrimitive, |
| *mpOutputDevice, |
| maCurrentTransformation, |
| maBColorModifierStack)) |
| { |
| // fallback to decomposition (MetaFile) |
| process(rWrongSpellPrimitive.get2DDecomposition(getViewInformation2D())); |
| } |
| } |
| else |
| { |
| process(rCandidate.get2DDecomposition(getViewInformation2D())); |
| } |
| break; |
| } |
| case PRIMITIVE2D_ID_TEXTSIMPLEPORTIONPRIMITIVE2D : |
| { |
| // directdraw of text simple portion; added test possibility to check text decompose |
| static bool bForceSimpleTextDecomposition(false); |
| |
| // Adapt evtl. used special DrawMode |
| const sal_uInt32 nOriginalDrawMode(mpOutputDevice->GetDrawMode()); |
| adaptTextToFillDrawMode(); |
| |
| if(!bForceSimpleTextDecomposition && getOptionsDrawinglayer().IsRenderSimpleTextDirect()) |
| { |
| RenderTextSimpleOrDecoratedPortionPrimitive2D(static_cast< const primitive2d::TextSimplePortionPrimitive2D& >(rCandidate)); |
| } |
| else |
| { |
| process(rCandidate.get2DDecomposition(getViewInformation2D())); |
| } |
| |
| // restore DrawMode |
| mpOutputDevice->SetDrawMode(nOriginalDrawMode); |
| |
| break; |
| } |
| case PRIMITIVE2D_ID_TEXTDECORATEDPORTIONPRIMITIVE2D : |
| { |
| // directdraw of text simple portion; added test possibility to check text decompose |
| static bool bForceComplexTextDecomposition(false); |
| |
| // Adapt evtl. used special DrawMode |
| const sal_uInt32 nOriginalDrawMode(mpOutputDevice->GetDrawMode()); |
| adaptTextToFillDrawMode(); |
| |
| if(!bForceComplexTextDecomposition && getOptionsDrawinglayer().IsRenderDecoratedTextDirect()) |
| { |
| RenderTextSimpleOrDecoratedPortionPrimitive2D(static_cast< const primitive2d::TextSimplePortionPrimitive2D& >(rCandidate)); |
| } |
| else |
| { |
| process(rCandidate.get2DDecomposition(getViewInformation2D())); |
| } |
| |
| // restore DrawMode |
| mpOutputDevice->SetDrawMode(nOriginalDrawMode); |
| |
| break; |
| } |
| case PRIMITIVE2D_ID_POLYGONHAIRLINEPRIMITIVE2D : |
| { |
| // direct draw of hairline |
| RenderPolygonHairlinePrimitive2D(static_cast< const primitive2d::PolygonHairlinePrimitive2D& >(rCandidate), true); |
| break; |
| } |
| case PRIMITIVE2D_ID_BITMAPPRIMITIVE2D : |
| { |
| // direct draw of transformed BitmapEx primitive |
| RenderBitmapPrimitive2D(static_cast< const primitive2d::BitmapPrimitive2D& >(rCandidate)); |
| break; |
| } |
| case PRIMITIVE2D_ID_FILLBITMAPPRIMITIVE2D : |
| { |
| // direct draw of fillBitmapPrimitive |
| RenderFillBitmapPrimitive2D(static_cast< const primitive2d::FillBitmapPrimitive2D& >(rCandidate)); |
| break; |
| } |
| case PRIMITIVE2D_ID_POLYPOLYGONGRADIENTPRIMITIVE2D : |
| { |
| // direct draw of gradient |
| RenderPolyPolygonGradientPrimitive2D(static_cast< const primitive2d::PolyPolygonGradientPrimitive2D& >(rCandidate)); |
| break; |
| } |
| case PRIMITIVE2D_ID_POLYPOLYGONBITMAPPRIMITIVE2D : |
| { |
| // direct draw of bitmap |
| RenderPolyPolygonBitmapPrimitive2D(static_cast< const primitive2d::PolyPolygonBitmapPrimitive2D& >(rCandidate)); |
| break; |
| } |
| case PRIMITIVE2D_ID_POLYPOLYGONCOLORPRIMITIVE2D : |
| { |
| // direct draw of PolyPolygon with color |
| RenderPolyPolygonColorPrimitive2D(static_cast< const primitive2d::PolyPolygonColorPrimitive2D& >(rCandidate)); |
| break; |
| } |
| case PRIMITIVE2D_ID_METAFILEPRIMITIVE2D : |
| { |
| // #i98289# |
| const bool bForceLineSnap(getOptionsDrawinglayer().IsAntiAliasing() && getOptionsDrawinglayer().IsSnapHorVerLinesToDiscrete()); |
| const sal_uInt16 nOldAntiAliase(mpOutputDevice->GetAntialiasing()); |
| |
| if(bForceLineSnap) |
| { |
| mpOutputDevice->SetAntialiasing(nOldAntiAliase | ANTIALIASING_PIXELSNAPHAIRLINE); |
| } |
| |
| static bool bTestMetaFilePrimitiveDecomposition(true); |
| if(bTestMetaFilePrimitiveDecomposition) |
| { |
| // use new Metafile decomposition |
| process(rCandidate.get2DDecomposition(getViewInformation2D())); |
| } |
| else |
| { |
| // direct draw of MetaFile |
| RenderMetafilePrimitive2D(static_cast< const primitive2d::MetafilePrimitive2D& >(rCandidate)); |
| } |
| |
| if(bForceLineSnap) |
| { |
| mpOutputDevice->SetAntialiasing(nOldAntiAliase); |
| } |
| |
| break; |
| } |
| case PRIMITIVE2D_ID_MASKPRIMITIVE2D : |
| { |
| // mask group. |
| RenderMaskPrimitive2DPixel(static_cast< const primitive2d::MaskPrimitive2D& >(rCandidate)); |
| break; |
| } |
| case PRIMITIVE2D_ID_MODIFIEDCOLORPRIMITIVE2D : |
| { |
| // modified color group. Force output to unified color. |
| RenderModifiedColorPrimitive2D(static_cast< const primitive2d::ModifiedColorPrimitive2D& >(rCandidate)); |
| break; |
| } |
| case PRIMITIVE2D_ID_UNIFIEDTRANSPARENCEPRIMITIVE2D : |
| { |
| // Detect if a single PolyPolygonColorPrimitive2D is contained; in that case, |
| // use the faster OutputDevice::DrawTransparent method |
| const primitive2d::UnifiedTransparencePrimitive2D& rUniTransparenceCandidate = static_cast< const primitive2d::UnifiedTransparencePrimitive2D& >(rCandidate); |
| const primitive2d::Primitive2DSequence rContent = rUniTransparenceCandidate.getChildren(); |
| |
| if(rContent.hasElements()) |
| { |
| if(0.0 == rUniTransparenceCandidate.getTransparence()) |
| { |
| // not transparent at all, use content |
| process(rUniTransparenceCandidate.getChildren()); |
| } |
| else if(rUniTransparenceCandidate.getTransparence() > 0.0 && rUniTransparenceCandidate.getTransparence() < 1.0) |
| { |
| bool bDrawTransparentUsed(false); |
| |
| // since DEV300 m33 DrawTransparent is supported in VCL (for some targets |
| // natively), so i am now enabling this shortcut |
| static bool bAllowUsingDrawTransparent(true); |
| |
| if(bAllowUsingDrawTransparent && 1 == rContent.getLength()) |
| { |
| const primitive2d::Primitive2DReference xReference(rContent[0]); |
| const primitive2d::BasePrimitive2D* pBasePrimitive = dynamic_cast< const primitive2d::BasePrimitive2D* >(xReference.get()); |
| |
| if(pBasePrimitive) |
| { |
| switch(pBasePrimitive->getPrimitive2DID()) |
| { |
| case PRIMITIVE2D_ID_POLYPOLYGONCOLORPRIMITIVE2D: |
| { |
| // single transparent PolyPolygon identified, use directly |
| const primitive2d::PolyPolygonColorPrimitive2D* pPoPoColor = static_cast< const primitive2d::PolyPolygonColorPrimitive2D* >(pBasePrimitive); |
| OSL_ENSURE(pPoPoColor, "OOps, PrimitiveID and PrimitiveType do not match (!)"); |
| const basegfx::BColor aPolygonColor(maBColorModifierStack.getModifiedColor(pPoPoColor->getBColor())); |
| mpOutputDevice->SetFillColor(Color(aPolygonColor)); |
| mpOutputDevice->SetLineColor(); |
| |
| basegfx::B2DPolyPolygon aLocalPolyPolygon(pPoPoColor->getB2DPolyPolygon()); |
| aLocalPolyPolygon.transform(maCurrentTransformation); |
| |
| mpOutputDevice->DrawTransparent(aLocalPolyPolygon, rUniTransparenceCandidate.getTransparence()); |
| bDrawTransparentUsed = true; |
| break; |
| } |
| // #i# need to wait for #i101378# which is in CWS vcl112 to directly paint transparent hairlines |
| //case PRIMITIVE2D_ID_POLYGONHAIRLINEPRIMITIVE2D: |
| //{ |
| // // single transparent PolygonHairlinePrimitive2D identified, use directly |
| // const primitive2d::PolygonHairlinePrimitive2D* pPoHair = static_cast< const primitive2d::PolygonHairlinePrimitive2D* >(pBasePrimitive); |
| // OSL_ENSURE(pPoHair, "OOps, PrimitiveID and PrimitiveType do not match (!)"); |
| // break; |
| //} |
| } |
| } |
| } |
| |
| if(!bDrawTransparentUsed) |
| { |
| // unified sub-transparence. Draw to VDev first. |
| RenderUnifiedTransparencePrimitive2D(rUniTransparenceCandidate); |
| } |
| } |
| } |
| |
| break; |
| } |
| case PRIMITIVE2D_ID_TRANSPARENCEPRIMITIVE2D : |
| { |
| // sub-transparence group. Draw to VDev first. |
| RenderTransparencePrimitive2D(static_cast< const primitive2d::TransparencePrimitive2D& >(rCandidate)); |
| break; |
| } |
| case PRIMITIVE2D_ID_TRANSFORMPRIMITIVE2D : |
| { |
| // transform group. |
| RenderTransformPrimitive2D(static_cast< const primitive2d::TransformPrimitive2D& >(rCandidate)); |
| break; |
| } |
| case PRIMITIVE2D_ID_PAGEPREVIEWPRIMITIVE2D : |
| { |
| // new XDrawPage for ViewInformation2D |
| RenderPagePreviewPrimitive2D(static_cast< const primitive2d::PagePreviewPrimitive2D& >(rCandidate)); |
| break; |
| } |
| case PRIMITIVE2D_ID_MARKERARRAYPRIMITIVE2D : |
| { |
| // marker array |
| RenderMarkerArrayPrimitive2D(static_cast< const primitive2d::MarkerArrayPrimitive2D& >(rCandidate)); |
| break; |
| } |
| case PRIMITIVE2D_ID_POINTARRAYPRIMITIVE2D : |
| { |
| // point array |
| RenderPointArrayPrimitive2D(static_cast< const primitive2d::PointArrayPrimitive2D& >(rCandidate)); |
| break; |
| } |
| case PRIMITIVE2D_ID_CONTROLPRIMITIVE2D : |
| { |
| // control primitive |
| const primitive2d::ControlPrimitive2D& rControlPrimitive = static_cast< const primitive2d::ControlPrimitive2D& >(rCandidate); |
| const uno::Reference< awt::XControl >& rXControl(rControlPrimitive.getXControl()); |
| |
| try |
| { |
| // remember old graphics and create new |
| uno::Reference< awt::XView > xControlView(rXControl, uno::UNO_QUERY_THROW); |
| const uno::Reference< awt::XGraphics > xOriginalGraphics(xControlView->getGraphics()); |
| const uno::Reference< awt::XGraphics > xNewGraphics(mpOutputDevice->CreateUnoGraphics()); |
| |
| if(xNewGraphics.is()) |
| { |
| // link graphics and view |
| xControlView->setGraphics(xNewGraphics); |
| |
| // get position |
| const basegfx::B2DHomMatrix aObjectToPixel(maCurrentTransformation * rControlPrimitive.getTransform()); |
| const basegfx::B2DPoint aTopLeftPixel(aObjectToPixel * basegfx::B2DPoint(0.0, 0.0)); |
| |
| // find out if the control is already visualized as a VCL-ChildWindow. If yes, |
| // it does not need to be painted at all. |
| uno::Reference< awt::XWindow2 > xControlWindow(rXControl, uno::UNO_QUERY_THROW); |
| const bool bControlIsVisibleAsChildWindow(rXControl->getPeer().is() && xControlWindow->isVisible()); |
| |
| if(!bControlIsVisibleAsChildWindow) |
| { |
| // draw it. Do not forget to use the evtl. offsetted origin of the target device, |
| // e.g. when used with mask/transparence buffer device |
| const Point aOrigin(mpOutputDevice->GetMapMode().GetOrigin()); |
| xControlView->draw( |
| aOrigin.X() + basegfx::fround(aTopLeftPixel.getX()), |
| aOrigin.Y() + basegfx::fround(aTopLeftPixel.getY())); |
| } |
| |
| // restore original graphics |
| xControlView->setGraphics(xOriginalGraphics); |
| } |
| } |
| catch(const uno::Exception&) |
| { |
| // #i116763# removing since there is a good alternative when the xControlView |
| // is not found and it is allowed to happen |
| // DBG_UNHANDLED_EXCEPTION(); |
| |
| // process recursively and use the decomposition as Bitmap |
| process(rCandidate.get2DDecomposition(getViewInformation2D())); |
| } |
| |
| break; |
| } |
| case PRIMITIVE2D_ID_POLYGONSTROKEPRIMITIVE2D: |
| { |
| // the stroke primitive may be decomposed to filled polygons. To keep |
| // evtl. set DrawModes aka DRAWMODE_BLACKLINE, DRAWMODE_GRAYLINE, |
| // DRAWMODE_GHOSTEDLINE, DRAWMODE_WHITELINE or DRAWMODE_SETTINGSLINE |
| // working, these need to be copied to the corresponding fill modes |
| const sal_uInt32 nOriginalDrawMode(mpOutputDevice->GetDrawMode()); |
| adaptLineToFillDrawMode(); |
| |
| // polygon stroke primitive |
| static bool bSuppressFatToHairlineCorrection(false); |
| |
| if(bSuppressFatToHairlineCorrection) |
| { |
| // remeber that we enter a PolygonStrokePrimitive2D decomposition, |
| // used for AA thick line drawing |
| mnPolygonStrokePrimitive2D++; |
| |
| // with AA there is no need to handle thin lines special |
| process(rCandidate.get2DDecomposition(getViewInformation2D())); |
| |
| // leave PolygonStrokePrimitive2D |
| mnPolygonStrokePrimitive2D--; |
| } |
| else |
| { |
| // Lines with 1 and 2 pixel width without AA need special treatment since their vsiualisation |
| // as filled polygons is geometrically corret but looks wrong since polygon filling avoids |
| // the right and bottom pixels. The used method evaluates that and takes the correct action, |
| // including calling recursively with decomposition if line is wide enough |
| const primitive2d::PolygonStrokePrimitive2D& rPolygonStrokePrimitive = static_cast< const primitive2d::PolygonStrokePrimitive2D& >(rCandidate); |
| |
| RenderPolygonStrokePrimitive2D(rPolygonStrokePrimitive); |
| } |
| |
| // restore DrawMode |
| mpOutputDevice->SetDrawMode(nOriginalDrawMode); |
| |
| break; |
| } |
| case PRIMITIVE2D_ID_FILLHATCHPRIMITIVE2D : |
| { |
| static bool bForceIgnoreHatchSmoothing(false); |
| |
| if(bForceIgnoreHatchSmoothing || getOptionsDrawinglayer().IsAntiAliasing()) |
| { |
| // if AA is used (or ignore smoothing is on), there is no need to smooth |
| // hatch painting, use decomposition |
| process(rCandidate.get2DDecomposition(getViewInformation2D())); |
| } |
| else |
| { |
| // without AA, use VCL to draw the hatch. It snaps hatch distances to the next pixel |
| // and forces hatch distance to be >= 3 pixels to make the hatch display look smoother. |
| // This is wrong in principle, but looks nicer. This could also be done here directly |
| // without VCL usage if needed |
| const primitive2d::FillHatchPrimitive2D& rFillHatchPrimitive = static_cast< const primitive2d::FillHatchPrimitive2D& >(rCandidate); |
| const attribute::FillHatchAttribute& rFillHatchAttributes = rFillHatchPrimitive.getFillHatch(); |
| |
| // create hatch polygon in range size and discrete coordinates |
| basegfx::B2DRange aHatchRange(rFillHatchPrimitive.getObjectRange()); |
| aHatchRange.transform(maCurrentTransformation); |
| const basegfx::B2DPolygon aHatchPolygon(basegfx::tools::createPolygonFromRect(aHatchRange)); |
| |
| if(rFillHatchAttributes.isFillBackground()) |
| { |
| // #i111846# background fill is active; draw fill polygon |
| const basegfx::BColor aPolygonColor(maBColorModifierStack.getModifiedColor(rFillHatchPrimitive.getBColor())); |
| |
| mpOutputDevice->SetFillColor(Color(aPolygonColor)); |
| mpOutputDevice->SetLineColor(); |
| mpOutputDevice->DrawPolygon(aHatchPolygon); |
| } |
| |
| // set hatch line color |
| const basegfx::BColor aHatchColor(maBColorModifierStack.getModifiedColor(rFillHatchPrimitive.getBColor())); |
| mpOutputDevice->SetFillColor(); |
| mpOutputDevice->SetLineColor(Color(aHatchColor)); |
| |
| // get hatch style |
| HatchStyle eHatchStyle(HATCH_SINGLE); |
| |
| switch(rFillHatchAttributes.getStyle()) |
| { |
| default : // HATCHSTYLE_SINGLE |
| { |
| break; |
| } |
| case attribute::HATCHSTYLE_DOUBLE : |
| { |
| eHatchStyle = HATCH_DOUBLE; |
| break; |
| } |
| case attribute::HATCHSTYLE_TRIPLE : |
| { |
| eHatchStyle = HATCH_TRIPLE; |
| break; |
| } |
| } |
| |
| // create hatch |
| const basegfx::B2DVector aDiscreteDistance(maCurrentTransformation * basegfx::B2DVector(rFillHatchAttributes.getDistance(), 0.0)); |
| const sal_uInt32 nDistance(basegfx::fround(aDiscreteDistance.getLength())); |
| const sal_uInt16 nAngle10((sal_uInt16)basegfx::fround(rFillHatchAttributes.getAngle() / F_PI1800)); |
| ::Hatch aVCLHatch(eHatchStyle, Color(rFillHatchAttributes.getColor()), nDistance, nAngle10); |
| |
| // draw hatch using VCL |
| mpOutputDevice->DrawHatch(PolyPolygon(Polygon(aHatchPolygon)), aVCLHatch); |
| } |
| break; |
| } |
| case PRIMITIVE2D_ID_BACKGROUNDCOLORPRIMITIVE2D : |
| { |
| // #i98404# Handle directly, especially when AA is active |
| const primitive2d::BackgroundColorPrimitive2D& rPrimitive = static_cast< const primitive2d::BackgroundColorPrimitive2D& >(rCandidate); |
| const sal_uInt16 nOriginalAA(mpOutputDevice->GetAntialiasing()); |
| |
| // switch AA off in all cases |
| mpOutputDevice->SetAntialiasing(mpOutputDevice->GetAntialiasing() & ~ANTIALIASING_ENABLE_B2DDRAW); |
| |
| // create color for fill |
| const basegfx::BColor aPolygonColor(maBColorModifierStack.getModifiedColor(rPrimitive.getBColor())); |
| mpOutputDevice->SetFillColor(Color(aPolygonColor)); |
| mpOutputDevice->SetLineColor(); |
| |
| // create rectangle for fill |
| const basegfx::B2DRange& aViewport(getViewInformation2D().getDiscreteViewport()); |
| const Rectangle aRectangle( |
| (sal_Int32)floor(aViewport.getMinX()), (sal_Int32)floor(aViewport.getMinY()), |
| (sal_Int32)ceil(aViewport.getMaxX()), (sal_Int32)ceil(aViewport.getMaxY())); |
| mpOutputDevice->DrawRect(aRectangle); |
| |
| // restore AA setting |
| mpOutputDevice->SetAntialiasing(nOriginalAA); |
| break; |
| } |
| case PRIMITIVE2D_ID_TEXTHIERARCHYEDITPRIMITIVE2D : |
| { |
| // #i97628# |
| // This primitive means that the content is derived from an active text edit, |
| // not from model data itself. Some renderers need to suppress this content, e.g. |
| // the pixel renderer used for displaying the edit view (like this one). It's |
| // not to be suppressed by the MetaFile renderers, so that the edited text is |
| // part of the MetaFile, e.g. needed for presentation previews. |
| // Action: Ignore here, do nothing. |
| break; |
| } |
| case PRIMITIVE2D_ID_INVERTPRIMITIVE2D : |
| { |
| // invert primitive (currently only used for HighContrast fallback for selection in SW and SC). |
| // Set OutDev to XOR and switch AA off (XOR does not work with AA) |
| mpOutputDevice->Push(); |
| mpOutputDevice->SetRasterOp( ROP_XOR ); |
| const sal_uInt16 nAntiAliasing(mpOutputDevice->GetAntialiasing()); |
| mpOutputDevice->SetAntialiasing(nAntiAliasing & ~ANTIALIASING_ENABLE_B2DDRAW); |
| |
| // process content recursively |
| process(rCandidate.get2DDecomposition(getViewInformation2D())); |
| |
| // restore OutDev |
| mpOutputDevice->Pop(); |
| mpOutputDevice->SetAntialiasing(nAntiAliasing); |
| break; |
| } |
| case PRIMITIVE2D_ID_EPSPRIMITIVE2D : |
| { |
| RenderEpsPrimitive2D(static_cast< const primitive2d::EpsPrimitive2D& >(rCandidate)); |
| break; |
| } |
| case PRIMITIVE2D_ID_SVGLINEARATOMPRIMITIVE2D: |
| { |
| RenderSvgLinearAtomPrimitive2D(static_cast< const primitive2d::SvgLinearAtomPrimitive2D& >(rCandidate)); |
| break; |
| } |
| case PRIMITIVE2D_ID_SVGRADIALATOMPRIMITIVE2D: |
| { |
| RenderSvgRadialAtomPrimitive2D(static_cast< const primitive2d::SvgRadialAtomPrimitive2D& >(rCandidate)); |
| break; |
| } |
| default : |
| { |
| // process recursively |
| process(rCandidate.get2DDecomposition(getViewInformation2D())); |
| break; |
| } |
| } |
| } |
| } // end of namespace processor2d |
| } // end of namespace drawinglayer |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // eof |
