office-gobmx/drawinglayer/source/processor2d/canvasprocessor.cxx
2012-01-21 19:58:46 +01:00

1011 lines
52 KiB
C++

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2000, 2010 Oracle and/or its affiliates.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
#include <drawinglayer/processor2d/canvasprocessor.hxx>
#include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx>
#include <drawinglayer/primitive2d/polygonprimitive2d.hxx>
#include <com/sun/star/rendering/XCanvas.hpp>
#include <vcl/canvastools.hxx>
#include <basegfx/tools/canvastools.hxx>
#include <drawinglayer/primitive2d/polypolygonprimitive2d.hxx>
#include <drawinglayer/primitive2d/modifiedcolorprimitive2d.hxx>
#include <drawinglayer/primitive2d/transformprimitive2d.hxx>
#include <canvas/canvastools.hxx>
#include <drawinglayer/primitive2d/maskprimitive2d.hxx>
#include <basegfx/polygon/b2dpolygonclipper.hxx>
#include <drawinglayer/primitive2d/pagepreviewprimitive2d.hxx>
#include <drawinglayer/primitive2d/metafileprimitive2d.hxx>
#include <cppcanvas/basegfxfactory.hxx>
#include <com/sun/star/rendering/XBitmapCanvas.hpp>
#include <cppcanvas/vclfactory.hxx>
#include <drawinglayer/primitive2d/pointarrayprimitive2d.hxx>
#include <drawinglayer/primitive2d/textprimitive2d.hxx>
#include <com/sun/star/rendering/TextDirection.hpp>
#include <vclhelperbitmaptransform.hxx>
#include <drawinglayer/primitive2d/bitmapprimitive2d.hxx>
#include <basegfx/polygon/b2dpolygontools.hxx>
#include <drawinglayer/primitive2d/transparenceprimitive2d.hxx>
#include <basegfx/tuple/b2i64tuple.hxx>
#include <basegfx/range/b2irange.hxx>
#include <com/sun/star/rendering/XIntegerReadOnlyBitmap.hpp>
#include <com/sun/star/rendering/PanoseProportion.hpp>
#include <com/sun/star/rendering/CompositeOperation.hpp>
#include <com/sun/star/rendering/StrokeAttributes.hpp>
#include <com/sun/star/rendering/PathJoinType.hpp>
#include <drawinglayer/primitive2d/fillbitmapprimitive2d.hxx>
#include <com/sun/star/rendering/TexturingMode.hpp>
#include <drawinglayer/primitive2d/unifiedtransparenceprimitive2d.hxx>
#include <vclhelperbufferdevice.hxx>
#include <drawinglayer/primitive2d/chartprimitive2d.hxx>
#include <helperchartrenderer.hxx>
#include <drawinglayer/primitive2d/wrongspellprimitive2d.hxx>
#include <helperwrongspellrenderer.hxx>
#include <basegfx/matrix/b2dhommatrixtools.hxx>
#include "getdigitlanguage.hxx"
//////////////////////////////////////////////////////////////////////////////
using namespace com::sun::star;
//////////////////////////////////////////////////////////////////////////////
namespace drawinglayer
{
namespace processor2d
{
//////////////////////////////////////////////////////////////////////////////
// single primitive renderers
void canvasProcessor2D::impRenderMaskPrimitive2D(const primitive2d::MaskPrimitive2D& rMaskCandidate)
{
const primitive2d::Primitive2DSequence& rChildren = rMaskCandidate.getChildren();
static bool bUseMaskBitmapMethod(true);
if(rChildren.hasElements())
{
basegfx::B2DPolyPolygon aMask(rMaskCandidate.getMask());
if(!aMask.count())
{
// no mask, no clipping. recursively paint content
process(rChildren);
}
else
{
// there are principally two methods for implementing the mask primitive. One
// is to set a clip polygon at the canvas, the other is to create and use a
// transparence-using XBitmap for content and draw the mask as transparence. Both have their
// advantages and disadvantages, so here are both with a bool allowing simple
// change
if(bUseMaskBitmapMethod)
{
// get logic range of transparent part, clip with ViewRange
basegfx::B2DRange aLogicRange(aMask.getB2DRange());
if(!getViewInformation2D().getViewport().isEmpty())
{
aLogicRange.intersect(getViewInformation2D().getViewport());
}
if(!aLogicRange.isEmpty())
{
// get discrete range of transparent part
basegfx::B2DRange aDiscreteRange(aLogicRange);
aDiscreteRange.transform(getViewInformation2D().getObjectToViewTransformation());
// expand to next covering discrete values (pixel bounds)
aDiscreteRange.expand(basegfx::B2DTuple(floor(aDiscreteRange.getMinX()), floor(aDiscreteRange.getMinY())));
aDiscreteRange.expand(basegfx::B2DTuple(ceil(aDiscreteRange.getMaxX()), ceil(aDiscreteRange.getMaxY())));
// use VCL-based buffer device
impBufferDevice aBufferDevice(*mpOutputDevice, aDiscreteRange, false);
if(aBufferDevice.isVisible())
{
// remember current OutDev, Canvas and ViewInformation
OutputDevice* pLastOutputDevice = mpOutputDevice;
uno::Reference< rendering::XCanvas > xLastCanvas(mxCanvas);
const geometry::ViewInformation2D aLastViewInformation2D(getViewInformation2D());
// prepare discrete offset for XBitmap, do not forget that the buffer bitmap
// may be truncated to discrete visible pixels
const basegfx::B2DHomMatrix aDiscreteOffset(basegfx::tools::createTranslateB2DHomMatrix(
aDiscreteRange.getMinX() > 0.0 ? -aDiscreteRange.getMinX() : 0.0,
aDiscreteRange.getMinY() > 0.0 ? -aDiscreteRange.getMinY() : 0.0));
// create new local ViewInformation2D with new transformation
const geometry::ViewInformation2D aViewInformation2D(
getViewInformation2D().getObjectTransformation(),
aDiscreteOffset * getViewInformation2D().getViewTransformation(),
getViewInformation2D().getViewport(),
getViewInformation2D().getVisualizedPage(),
getViewInformation2D().getViewTime(),
getViewInformation2D().getExtendedInformationSequence());
updateViewInformation(aViewInformation2D);
// set OutDev and Canvas to content target
mpOutputDevice = &aBufferDevice.getContent();
mxCanvas = mpOutputDevice->GetCanvas();
canvas::tools::setViewStateTransform(maViewState, getViewInformation2D().getViewTransformation());
// if ViewState transform is changed, the clipping polygon needs to be adapted, too
const basegfx::B2DPolyPolygon aOldClipPolyPolygon(maClipPolyPolygon);
if(maClipPolyPolygon.count())
{
maClipPolyPolygon.transform(aDiscreteOffset);
maViewState.Clip = basegfx::unotools::xPolyPolygonFromB2DPolyPolygon(mxCanvas->getDevice(), maClipPolyPolygon);
}
// paint content
process(rChildren);
// draw mask
const basegfx::BColor aBlack(0.0, 0.0, 0.0);
maRenderState.DeviceColor = aBlack.colorToDoubleSequence(mxCanvas->getDevice());
if(getOptionsDrawinglayer().IsAntiAliasing())
{
// with AA, use 8bit AlphaMask to get nice borders
VirtualDevice& rTransparence = aBufferDevice.getTransparence();
rTransparence.GetCanvas()->fillPolyPolygon(
basegfx::unotools::xPolyPolygonFromB2DPolyPolygon(mxCanvas->getDevice(), aMask),
maViewState, maRenderState);
}
else
{
// No AA, use 1bit mask
VirtualDevice& rMask = aBufferDevice.getMask();
rMask.GetCanvas()->fillPolyPolygon(
basegfx::unotools::xPolyPolygonFromB2DPolyPolygon(mxCanvas->getDevice(), aMask),
maViewState, maRenderState);
}
// back to old color stack, OutDev, Canvas and ViewTransform
mpOutputDevice = pLastOutputDevice;
mxCanvas = xLastCanvas;
updateViewInformation(aLastViewInformation2D);
canvas::tools::setViewStateTransform(maViewState, getViewInformation2D().getViewTransformation());
// restore clipping polygon
maClipPolyPolygon = aOldClipPolyPolygon;
if(maClipPolyPolygon.count())
{
maViewState.Clip = basegfx::unotools::xPolyPolygonFromB2DPolyPolygon(mxCanvas->getDevice(), maClipPolyPolygon);
}
// dump buffer to outdev
aBufferDevice.paint();
}
}
}
else
{
// transform new mask polygon to view coordinates for processing. All masks
// are processed in view coordinates and clipped against each other evtl. to
// create multi-clips
aMask.transform(getViewInformation2D().getObjectTransformation());
// remember last current clip polygon
const basegfx::B2DPolyPolygon aLastClipPolyPolygon(maClipPolyPolygon);
if(maClipPolyPolygon.count())
{
// there is already a clip polygon set; build clipped union of
// current mask polygon and new one
maClipPolyPolygon = basegfx::tools::clipPolyPolygonOnPolyPolygon(aMask, maClipPolyPolygon, false, false);
}
else
{
// use mask directly
maClipPolyPolygon = aMask;
}
// set at ViewState
if(maClipPolyPolygon.count())
{
// set new as clip polygon
maViewState.Clip = basegfx::unotools::xPolyPolygonFromB2DPolyPolygon(mxCanvas->getDevice(), maClipPolyPolygon);
}
else
{
// empty, reset
maViewState.Clip.clear();
}
// paint content
process(rChildren);
// restore local current to rescued clip polygon
maClipPolyPolygon = aLastClipPolyPolygon;
// set at ViewState
if(maClipPolyPolygon.count())
{
// set new as clip polygon
maViewState.Clip = basegfx::unotools::xPolyPolygonFromB2DPolyPolygon(mxCanvas->getDevice(), maClipPolyPolygon);
}
else
{
// empty, reset
maViewState.Clip.clear();
}
}
}
}
}
void canvasProcessor2D::impRenderMetafilePrimitive2D(const primitive2d::MetafilePrimitive2D& rMetaCandidate)
{
GDIMetaFile aMetaFile;
if(maBColorModifierStack.count())
{
const basegfx::BColor aRGBBaseColor(0, 0, 0);
const basegfx::BColor aRGBColor(maBColorModifierStack.getModifiedColor(aRGBBaseColor));
aMetaFile = rMetaCandidate.getMetaFile().GetMonochromeMtf(Color(aRGBColor));
}
else
{
aMetaFile = rMetaCandidate.getMetaFile();
}
cppcanvas::BitmapCanvasSharedPtr pCanvas(cppcanvas::VCLFactory::getInstance().createCanvas(
uno::Reference<rendering::XBitmapCanvas>(mxCanvas, uno::UNO_QUERY_THROW)));
cppcanvas::RendererSharedPtr pMtfRenderer(cppcanvas::VCLFactory::getInstance().createRenderer(
pCanvas, aMetaFile, cppcanvas::Renderer::Parameters()));
if(pMtfRenderer)
{
pCanvas->setTransformation(getViewInformation2D().getObjectToViewTransformation());
pMtfRenderer->setTransformation(rMetaCandidate.getTransform());
pMtfRenderer->draw();
}
}
void canvasProcessor2D::impRenderTextSimplePortionPrimitive2D(const primitive2d::TextSimplePortionPrimitive2D& rTextCandidate)
{
if(rTextCandidate.getTextLength())
{
double fShearX(0.0);
{
const basegfx::B2DHomMatrix aLocalTransform(getViewInformation2D().getObjectToViewTransformation() * rTextCandidate.getTextTransform());
basegfx::B2DVector aScale, aTranslate;
double fRotate;
aLocalTransform.decompose(aScale, aTranslate, fRotate, fShearX);
}
if(!basegfx::fTools::equalZero(fShearX))
{
// text is sheared. As long as the canvas renderers do not support this,
// use the decomposed primitive
process(rTextCandidate.get2DDecomposition(getViewInformation2D()));
}
else
{
const attribute::FontAttribute& rFontAttr(rTextCandidate.getFontAttribute());
rendering::FontRequest aFontRequest;
aFontRequest.FontDescription.FamilyName = rFontAttr.getFamilyName();
aFontRequest.FontDescription.StyleName = rFontAttr.getStyleName();
aFontRequest.FontDescription.IsSymbolFont = rFontAttr.getSymbol() ? util::TriState_YES : util::TriState_NO;
aFontRequest.FontDescription.IsVertical = rFontAttr.getVertical() ? util::TriState_YES : util::TriState_NO;
// TODO(F2): improve vclenum->panose conversion
aFontRequest.FontDescription.FontDescription.Weight = static_cast< sal_uInt8 >(rFontAttr.getWeight());
aFontRequest.FontDescription.FontDescription.Proportion =
rFontAttr.getMonospaced()
? rendering::PanoseProportion::MONO_SPACED
: rendering::PanoseProportion::ANYTHING;
aFontRequest.FontDescription.FontDescription.Letterform = rFontAttr.getItalic() ? 9 : 0;
// init CellSize to 1.0, else a default font height will be used
aFontRequest.CellSize = 1.0;
aFontRequest.Locale = rTextCandidate.getLocale();
// font matrix should only be used for glyph rotations etc.
com::sun::star::geometry::Matrix2D aFontMatrix;
canvas::tools::setIdentityMatrix2D(aFontMatrix);
uno::Reference<rendering::XCanvasFont> xFont(mxCanvas->createFont(
aFontRequest, uno::Sequence< beans::PropertyValue >(), aFontMatrix));
if(xFont.is())
{
// got a font, now try to get a TextLayout
const rendering::StringContext aStringContext(
rTextCandidate.getText(), rTextCandidate.getTextPosition(), rTextCandidate.getTextLength());
uno::Reference<rendering::XTextLayout> xLayout(xFont->createTextLayout(
aStringContext, com::sun::star::rendering::TextDirection::WEAK_LEFT_TO_RIGHT, 0));
if(xLayout.is())
{
// got a text layout, apply DXArray if given
const ::std::vector< double >& rDXArray = rTextCandidate.getDXArray();
const sal_uInt32 nDXCount(rDXArray.size());
if(nDXCount)
{
// DXArray does not need to be adapted to getTextPosition/getTextLength,
// it is already provided correctly
const uno::Sequence< double > aDXSequence(&rDXArray[0], nDXCount);
xLayout->applyLogicalAdvancements(aDXSequence);
}
// set text color
const basegfx::BColor aRGBColor(maBColorModifierStack.getModifiedColor(rTextCandidate.getFontColor()));
maRenderState.DeviceColor = aRGBColor.colorToDoubleSequence(mxCanvas->getDevice());
// set text transformation
canvas::tools::setRenderStateTransform(maRenderState,
getViewInformation2D().getObjectTransformation() * rTextCandidate.getTextTransform());
// paint
mxCanvas->drawTextLayout(xLayout, maViewState, maRenderState);
}
}
}
}
}
void canvasProcessor2D::impRenderBitmapPrimitive2D(const primitive2d::BitmapPrimitive2D& rBitmapCandidate)
{
// apply possible color modification to BitmapEx
BitmapEx aModifiedBitmapEx(impModifyBitmapEx(maBColorModifierStack, rBitmapCandidate.getBitmapEx()));
if(aModifiedBitmapEx.IsEmpty())
{
// replace with color filled polygon
const basegfx::BColor aModifiedColor(maBColorModifierStack.getModifiedColor(basegfx::BColor()));
const basegfx::B2DPolygon aPolygon(basegfx::tools::createUnitPolygon());
maRenderState.DeviceColor = aModifiedColor.colorToDoubleSequence(mxCanvas->getDevice());
canvas::tools::setRenderStateTransform(maRenderState,
getViewInformation2D().getObjectTransformation() * rBitmapCandidate.getTransform());
mxCanvas->fillPolyPolygon(basegfx::unotools::xPolyPolygonFromB2DPolyPolygon(
mxCanvas->getDevice(), basegfx::B2DPolyPolygon(aPolygon)), maViewState, maRenderState);
}
else
{
// adapt object's transformation to the correct scale
basegfx::B2DVector aScale, aTranslate;
const Size aSizePixel(aModifiedBitmapEx.GetSizePixel());
if(0 != aSizePixel.Width() && 0 != aSizePixel.Height())
{
double fRotate, fShearX;
rBitmapCandidate.getTransform().decompose(aScale, aTranslate, fRotate, fShearX);
const basegfx::B2DHomMatrix aNewMatrix(basegfx::tools::createScaleShearXRotateTranslateB2DHomMatrix(
aScale.getX() / aSizePixel.Width(), aScale.getY() / aSizePixel.Height(),
fShearX, fRotate, aTranslate.getX(), aTranslate.getY()));
canvas::tools::setRenderStateTransform(maRenderState,
getViewInformation2D().getObjectTransformation() * aNewMatrix);
mxCanvas->drawBitmap(
vcl::unotools::xBitmapFromBitmapEx(mxCanvas->getDevice(), aModifiedBitmapEx),
maViewState, maRenderState);
}
}
}
void canvasProcessor2D::impRenderTransparencePrimitive2D(const primitive2d::TransparencePrimitive2D& rTransparenceCandidate)
{
const primitive2d::Primitive2DSequence& rChildren = rTransparenceCandidate.getChildren();
const primitive2d::Primitive2DSequence& rTransparence = rTransparenceCandidate.getTransparence();
if(rChildren.hasElements() && rTransparence.hasElements())
{
// get logic range of transparent part and clip with ViewRange
basegfx::B2DRange aLogicRange(primitive2d::getB2DRangeFromPrimitive2DSequence(rChildren, getViewInformation2D()));
if(!getViewInformation2D().getViewport().isEmpty())
{
aLogicRange.intersect(getViewInformation2D().getViewport());
}
if(!aLogicRange.isEmpty())
{
// get discrete range of transparent part
basegfx::B2DRange aDiscreteRange(aLogicRange);
aDiscreteRange.transform(getViewInformation2D().getObjectToViewTransformation());
// expand to next covering discrete values (pixel bounds)
aDiscreteRange.expand(basegfx::B2DTuple(floor(aDiscreteRange.getMinX()), floor(aDiscreteRange.getMinY())));
aDiscreteRange.expand(basegfx::B2DTuple(ceil(aDiscreteRange.getMaxX()), ceil(aDiscreteRange.getMaxY())));
// use VCL-based buffer device
impBufferDevice aBufferDevice(*mpOutputDevice, aDiscreteRange, false);
if(aBufferDevice.isVisible())
{
// remember current OutDev, Canvas and ViewInformation
OutputDevice* pLastOutputDevice = mpOutputDevice;
uno::Reference< rendering::XCanvas > xLastCanvas(mxCanvas);
const geometry::ViewInformation2D aLastViewInformation2D(getViewInformation2D());
// prepare discrete offset for XBitmap, do not forget that the buffer bitmap
// may be truncated to discrete visible pixels
const basegfx::B2DHomMatrix aDiscreteOffset(basegfx::tools::createTranslateB2DHomMatrix(
aDiscreteRange.getMinX() > 0.0 ? -aDiscreteRange.getMinX() : 0.0,
aDiscreteRange.getMinY() > 0.0 ? -aDiscreteRange.getMinY() : 0.0));
// create new local ViewInformation2D with new transformation
const geometry::ViewInformation2D aViewInformation2D(
getViewInformation2D().getObjectTransformation(),
aDiscreteOffset * getViewInformation2D().getViewTransformation(),
getViewInformation2D().getViewport(),
getViewInformation2D().getVisualizedPage(),
getViewInformation2D().getViewTime(),
getViewInformation2D().getExtendedInformationSequence());
updateViewInformation(aViewInformation2D);
// set OutDev and Canvas to content target
mpOutputDevice = &aBufferDevice.getContent();
mxCanvas = mpOutputDevice->GetCanvas();
canvas::tools::setViewStateTransform(maViewState, getViewInformation2D().getViewTransformation());
// if ViewState transform is changed, the clipping polygon needs to be adapted, too
const basegfx::B2DPolyPolygon aOldClipPolyPolygon(maClipPolyPolygon);
if(maClipPolyPolygon.count())
{
maClipPolyPolygon.transform(aDiscreteOffset);
maViewState.Clip = basegfx::unotools::xPolyPolygonFromB2DPolyPolygon(mxCanvas->getDevice(), maClipPolyPolygon);
}
// paint content
process(rChildren);
// set to mask
mpOutputDevice = &aBufferDevice.getTransparence();
mxCanvas = mpOutputDevice->GetCanvas();
canvas::tools::setViewStateTransform(maViewState, getViewInformation2D().getViewTransformation());
// when painting transparence masks, reset the color stack
basegfx::BColorModifierStack aLastBColorModifierStack(maBColorModifierStack);
maBColorModifierStack = basegfx::BColorModifierStack();
// paint mask to it (always with transparence intensities, evtl. with AA)
process(rTransparence);
// back to old color stack, OutDev, Canvas and ViewTransform
maBColorModifierStack = aLastBColorModifierStack;
mpOutputDevice = pLastOutputDevice;
mxCanvas = xLastCanvas;
updateViewInformation(aLastViewInformation2D);
canvas::tools::setViewStateTransform(maViewState, getViewInformation2D().getViewTransformation());
// restore clipping polygon
maClipPolyPolygon = aOldClipPolyPolygon;
if(maClipPolyPolygon.count())
{
maViewState.Clip = basegfx::unotools::xPolyPolygonFromB2DPolyPolygon(mxCanvas->getDevice(), maClipPolyPolygon);
}
// dump buffer to outdev
aBufferDevice.paint();
}
}
}
}
void canvasProcessor2D::impRenderPolygonStrokePrimitive2D(const primitive2d::PolygonStrokePrimitive2D& rPolygonStrokePrimitive)
{
// support direct fat line geometry. This moves the decomposition to the canvas.
// As long as our canvases are used (which also use basegfx tooling) this makes
// no difference, but potentially canvases may better support this
static bool bSupportFatLineDirectly(true);
bool bOutputDone(false);
if(bSupportFatLineDirectly)
{
const attribute::LineAttribute& rLineAttribute = rPolygonStrokePrimitive.getLineAttribute();
const attribute::StrokeAttribute& rStrokeAttribute = rPolygonStrokePrimitive.getStrokeAttribute();
if(0.0 < rLineAttribute.getWidth() || 0 != rStrokeAttribute.getDotDashArray().size())
{
rendering::StrokeAttributes aStrokeAttribute;
aStrokeAttribute.StrokeWidth = rLineAttribute.getWidth();
aStrokeAttribute.MiterLimit = 15.0; // degrees; maybe here (15.0 * F_PI180) is needed, not clear in the documentation
const ::std::vector< double >& rDotDashArray = rStrokeAttribute.getDotDashArray();
if(!rDotDashArray.empty())
{
aStrokeAttribute.DashArray = uno::Sequence< double >(&rDotDashArray[0], rDotDashArray.size());
}
switch(rLineAttribute.getLineJoin())
{
default: // B2DLINEJOIN_NONE, B2DLINEJOIN_MIDDLE
aStrokeAttribute.JoinType = rendering::PathJoinType::NONE;
break;
case basegfx::B2DLINEJOIN_BEVEL:
aStrokeAttribute.JoinType = rendering::PathJoinType::BEVEL;
break;
case basegfx::B2DLINEJOIN_MITER:
aStrokeAttribute.JoinType = rendering::PathJoinType::MITER;
break;
case basegfx::B2DLINEJOIN_ROUND:
aStrokeAttribute.JoinType = rendering::PathJoinType::ROUND;
break;
}
const basegfx::BColor aHairlineColor(maBColorModifierStack.getModifiedColor(rLineAttribute.getColor()));
maRenderState.DeviceColor = aHairlineColor.colorToDoubleSequence(mxCanvas->getDevice());
canvas::tools::setRenderStateTransform(maRenderState, getViewInformation2D().getObjectTransformation());
mxCanvas->strokePolyPolygon(
basegfx::unotools::xPolyPolygonFromB2DPolygon(mxCanvas->getDevice(), rPolygonStrokePrimitive.getB2DPolygon()),
maViewState, maRenderState, aStrokeAttribute);
bOutputDone = true;
}
}
if(!bOutputDone)
{
// process decomposition
process(rPolygonStrokePrimitive.get2DDecomposition(getViewInformation2D()));
}
}
void canvasProcessor2D::impRenderFillBitmapPrimitive2D(const primitive2d::FillBitmapPrimitive2D& rFillBitmapPrimitive2D)
{
// support tiled fills directly when tiling is on
static bool bSupportFillBitmapDirectly(true);
bool bOutputDone(false);
if(bSupportFillBitmapDirectly)
{
const attribute::FillBitmapAttribute& rFillBitmapAttribute = rFillBitmapPrimitive2D.getFillBitmap();
if(rFillBitmapAttribute.getTiling())
{
// apply possible color modification to Bitmap
const BitmapEx aChangedBitmapEx(impModifyBitmapEx(maBColorModifierStack, rFillBitmapAttribute.getBitmapEx()));
if(aChangedBitmapEx.IsEmpty())
{
// replace with color filled polygon
const basegfx::BColor aModifiedColor(maBColorModifierStack.getModifiedColor(basegfx::BColor()));
const basegfx::B2DPolygon aPolygon(basegfx::tools::createUnitPolygon());
maRenderState.DeviceColor = aModifiedColor.colorToDoubleSequence(mxCanvas->getDevice());
canvas::tools::setRenderStateTransform(maRenderState,
getViewInformation2D().getObjectTransformation() * rFillBitmapPrimitive2D.getTransformation());
mxCanvas->fillPolyPolygon(basegfx::unotools::xPolyPolygonFromB2DPolyPolygon(
mxCanvas->getDevice(), basegfx::B2DPolyPolygon(aPolygon)), maViewState, maRenderState);
}
else
{
const Size aSizePixel(aChangedBitmapEx.GetSizePixel());
if(0 != aSizePixel.Width() && 0 != aSizePixel.Height())
{
// create texture matrix from texture to object (where object is unit square here),
// so use values directly
const basegfx::B2DHomMatrix aTextureMatrix(basegfx::tools::createScaleTranslateB2DHomMatrix(
rFillBitmapAttribute.getSize().getX(), rFillBitmapAttribute.getSize().getY(),
rFillBitmapAttribute.getTopLeft().getX(), rFillBitmapAttribute.getTopLeft().getY()));
// create and fill texture
rendering::Texture aTexture;
basegfx::unotools::affineMatrixFromHomMatrix(aTexture.AffineTransform, aTextureMatrix);
aTexture.Alpha = 1.0;
aTexture.Bitmap = vcl::unotools::xBitmapFromBitmapEx(mxCanvas->getDevice(), aChangedBitmapEx);
aTexture.RepeatModeX = rendering::TexturingMode::REPEAT;
aTexture.RepeatModeY = rendering::TexturingMode::REPEAT;
// canvas needs a polygon to fill, create unit rectangle polygon
const basegfx::B2DPolygon aOutlineRectangle(basegfx::tools::createUnitPolygon());
// set primitive's transformation as render state transform
canvas::tools::setRenderStateTransform(maRenderState,
getViewInformation2D().getObjectTransformation() * rFillBitmapPrimitive2D.getTransformation());
// put texture into a uno sequence for handover
uno::Sequence< rendering::Texture > aSeq(1);
aSeq[0] = aTexture;
// draw textured rectangle
mxCanvas->fillTexturedPolyPolygon(
basegfx::unotools::xPolyPolygonFromB2DPolyPolygon(mxCanvas->getDevice(), basegfx::B2DPolyPolygon(aOutlineRectangle)),
maViewState, maRenderState, aSeq);
}
}
bOutputDone = true;
}
}
if(!bOutputDone)
{
// process decomposition
process(rFillBitmapPrimitive2D.get2DDecomposition(getViewInformation2D()));
}
}
void canvasProcessor2D::impRenderUnifiedTransparencePrimitive2D(const primitive2d::UnifiedTransparencePrimitive2D& rUniTransparenceCandidate)
{
if(0.0 == rUniTransparenceCandidate.getTransparence())
{
// not transparent at all, directly use content
process(rUniTransparenceCandidate.getChildren());
}
else if(rUniTransparenceCandidate.getTransparence() > 0.0 && rUniTransparenceCandidate.getTransparence() < 1.0)
{
const primitive2d::Primitive2DSequence rChildren = rUniTransparenceCandidate.getChildren();
if(rChildren.hasElements())
{
bool bOutputDone(false);
// Detect if a single PolyPolygonColorPrimitive2D is contained; in that case,
// use the fillPolyPolygon method with correctly set transparence. This is a often used
// case, so detectiong it is valuable
if(1 == rChildren.getLength())
{
const primitive2d::Primitive2DReference xReference(rChildren[0]);
const primitive2d::PolyPolygonColorPrimitive2D* pPoPoColor = dynamic_cast< const primitive2d::PolyPolygonColorPrimitive2D* >(xReference.get());
if(pPoPoColor && PRIMITIVE2D_ID_POLYPOLYGONCOLORPRIMITIVE2D == pPoPoColor->getPrimitive2DID())
{
// direct draw of PolyPolygon with color and transparence
const basegfx::BColor aPolygonColor(maBColorModifierStack.getModifiedColor(pPoPoColor->getBColor()));
// add transparence modulation value to DeviceColor
uno::Sequence< double > aColor(4);
aColor[0] = aPolygonColor.getRed();
aColor[1] = aPolygonColor.getGreen();
aColor[2] = aPolygonColor.getBlue();
aColor[3] = 1.0 - rUniTransparenceCandidate.getTransparence();
maRenderState.DeviceColor = aColor;
canvas::tools::setRenderStateTransform(maRenderState, getViewInformation2D().getObjectTransformation());
mxCanvas->fillPolyPolygon(
basegfx::unotools::xPolyPolygonFromB2DPolyPolygon(mxCanvas->getDevice(), pPoPoColor->getB2DPolyPolygon()),
maViewState, maRenderState);
bOutputDone = true;
}
}
if(!bOutputDone)
{
// process decomposition. This will be decomposed to an TransparencePrimitive2D
// with the same child context and a single polygon for transparent context. This could be
// directly handled here with known VCL-buffer technology, but would only
// make a small difference compared to directly rendering the TransparencePrimitive2D
// using impRenderTransparencePrimitive2D above.
process(rUniTransparenceCandidate.get2DDecomposition(getViewInformation2D()));
}
}
}
}
//////////////////////////////////////////////////////////////////////////////
// internal processing support
void canvasProcessor2D::processBasePrimitive2D(const primitive2d::BasePrimitive2D& rCandidate)
{
switch(rCandidate.getPrimitive2DID())
{
case PRIMITIVE2D_ID_POLYGONHAIRLINEPRIMITIVE2D :
{
// direct draw of hairline
const primitive2d::PolygonHairlinePrimitive2D& rPolygonCandidate = static_cast< const primitive2d::PolygonHairlinePrimitive2D& >(rCandidate);
const basegfx::BColor aHairlineColor(maBColorModifierStack.getModifiedColor(rPolygonCandidate.getBColor()));
maRenderState.DeviceColor = aHairlineColor.colorToDoubleSequence(mxCanvas->getDevice());
canvas::tools::setRenderStateTransform(maRenderState, getViewInformation2D().getObjectTransformation());
mxCanvas->drawPolyPolygon(
basegfx::unotools::xPolyPolygonFromB2DPolygon(mxCanvas->getDevice(), rPolygonCandidate.getB2DPolygon()),
maViewState, maRenderState);
break;
}
case PRIMITIVE2D_ID_POLYPOLYGONCOLORPRIMITIVE2D :
{
// direct draw of PolyPolygon with color
const primitive2d::PolyPolygonColorPrimitive2D& rPolygonCandidate = static_cast< const primitive2d::PolyPolygonColorPrimitive2D& >(rCandidate);
const basegfx::BColor aPolygonColor(maBColorModifierStack.getModifiedColor(rPolygonCandidate.getBColor()));
maRenderState.DeviceColor = aPolygonColor.colorToDoubleSequence(mxCanvas->getDevice());
canvas::tools::setRenderStateTransform(maRenderState, getViewInformation2D().getObjectTransformation());
mxCanvas->fillPolyPolygon(
basegfx::unotools::xPolyPolygonFromB2DPolyPolygon(mxCanvas->getDevice(), rPolygonCandidate.getB2DPolyPolygon()),
maViewState, maRenderState);
break;
}
case PRIMITIVE2D_ID_MODIFIEDCOLORPRIMITIVE2D :
{
// modified color group. Force output to unified color.
const primitive2d::ModifiedColorPrimitive2D& rModifiedCandidate = static_cast< const primitive2d::ModifiedColorPrimitive2D& >(rCandidate);
if(rModifiedCandidate.getChildren().hasElements())
{
maBColorModifierStack.push(rModifiedCandidate.getColorModifier());
process(rModifiedCandidate.getChildren());
maBColorModifierStack.pop();
}
break;
}
case PRIMITIVE2D_ID_MASKPRIMITIVE2D :
{
// mask group
impRenderMaskPrimitive2D(static_cast< const primitive2d::MaskPrimitive2D& >(rCandidate));
break;
}
case PRIMITIVE2D_ID_TRANSFORMPRIMITIVE2D :
{
// transform group. Remember current ViewInformation2D
const primitive2d::TransformPrimitive2D& rTransformCandidate = static_cast< const primitive2d::TransformPrimitive2D& >(rCandidate);
const geometry::ViewInformation2D aLastViewInformation2D(getViewInformation2D());
// create new local ViewInformation2D with new transformation
const geometry::ViewInformation2D aViewInformation2D(
getViewInformation2D().getObjectTransformation() * rTransformCandidate.getTransformation(),
getViewInformation2D().getViewTransformation(),
getViewInformation2D().getViewport(),
getViewInformation2D().getVisualizedPage(),
getViewInformation2D().getViewTime(),
getViewInformation2D().getExtendedInformationSequence());
updateViewInformation(aViewInformation2D);
// set at canvas
canvas::tools::setRenderStateTransform(maRenderState, getViewInformation2D().getObjectTransformation());
// proccess content
process(rTransformCandidate.getChildren());
// restore transformations
updateViewInformation(aLastViewInformation2D);
// restore at canvas
canvas::tools::setRenderStateTransform(maRenderState, getViewInformation2D().getObjectTransformation());
break;
}
case PRIMITIVE2D_ID_PAGEPREVIEWPRIMITIVE2D :
{
// new XDrawPage for ViewInformation2D
const primitive2d::PagePreviewPrimitive2D& rPagePreviewCandidate = static_cast< const primitive2d::PagePreviewPrimitive2D& >(rCandidate);
// remember current transformation and ViewInformation
const geometry::ViewInformation2D aLastViewInformation2D(getViewInformation2D());
// create new local ViewInformation2D
const geometry::ViewInformation2D aViewInformation2D(
getViewInformation2D().getObjectTransformation(),
getViewInformation2D().getViewTransformation(),
getViewInformation2D().getViewport(),
rPagePreviewCandidate.getXDrawPage(),
getViewInformation2D().getViewTime(),
getViewInformation2D().getExtendedInformationSequence());
updateViewInformation(aViewInformation2D);
// proccess decomposed content
process(rPagePreviewCandidate.get2DDecomposition(getViewInformation2D()));
// restore transformations
updateViewInformation(aLastViewInformation2D);
break;
}
case PRIMITIVE2D_ID_METAFILEPRIMITIVE2D :
{
// MetaFile primitive
impRenderMetafilePrimitive2D(static_cast< const primitive2d::MetafilePrimitive2D& >(rCandidate));
break;
}
case PRIMITIVE2D_ID_POINTARRAYPRIMITIVE2D :
{
// PointArray primitive
const primitive2d::PointArrayPrimitive2D& rPointArrayCandidate = static_cast< const primitive2d::PointArrayPrimitive2D& >(rCandidate);
// set point color
const basegfx::BColor aRGBColor(maBColorModifierStack.getModifiedColor(rPointArrayCandidate.getRGBColor()));
maRenderState.DeviceColor = aRGBColor.colorToDoubleSequence(mxCanvas->getDevice());
canvas::tools::setRenderStateTransform(maRenderState, getViewInformation2D().getObjectTransformation());
const std::vector< basegfx::B2DPoint >& rPointVector = rPointArrayCandidate.getPositions();
const sal_uInt32 nPointCount(rPointVector.size());
for(sal_uInt32 a(0); a < nPointCount; a++)
{
const basegfx::B2DPoint& rPoint = rPointVector[a];
mxCanvas->drawPoint(basegfx::unotools::point2DFromB2DPoint(rPoint), maViewState, maRenderState);
}
break;
}
case PRIMITIVE2D_ID_TEXTSIMPLEPORTIONPRIMITIVE2D :
{
// TextSimplePortion primitive
impRenderTextSimplePortionPrimitive2D(static_cast< const primitive2d::TextSimplePortionPrimitive2D& >(rCandidate));
break;
}
case PRIMITIVE2D_ID_BITMAPPRIMITIVE2D :
{
// Bitmap primitive
impRenderBitmapPrimitive2D(static_cast< const primitive2d::BitmapPrimitive2D& >(rCandidate));
break;
}
case PRIMITIVE2D_ID_TRANSPARENCEPRIMITIVE2D :
{
// Transparence primitive
impRenderTransparencePrimitive2D(static_cast< const primitive2d::TransparencePrimitive2D& >(rCandidate));
break;
}
case PRIMITIVE2D_ID_POLYGONSTROKEPRIMITIVE2D:
{
// PolygonStrokePrimitive
impRenderPolygonStrokePrimitive2D(static_cast< const primitive2d::PolygonStrokePrimitive2D& >(rCandidate));
break;
}
case PRIMITIVE2D_ID_FILLBITMAPPRIMITIVE2D :
{
// FillBitmapPrimitive2D
impRenderFillBitmapPrimitive2D(static_cast< const primitive2d::FillBitmapPrimitive2D& >(rCandidate));
break;
}
case PRIMITIVE2D_ID_UNIFIEDTRANSPARENCEPRIMITIVE2D :
{
// UnifiedTransparencePrimitive2D
impRenderUnifiedTransparencePrimitive2D(static_cast< const primitive2d::UnifiedTransparencePrimitive2D& >(rCandidate));
break;
}
case PRIMITIVE2D_ID_CHARTPRIMITIVE2D :
{
// chart primitive in canvas renderer; restore original DrawMode during call
// since the evtl. used ChartPrettyPainter will use the MapMode
const primitive2d::ChartPrimitive2D& rChartPrimitive = static_cast< const primitive2d::ChartPrimitive2D& >(rCandidate);
mpOutputDevice->Push(PUSH_MAPMODE);
mpOutputDevice->SetMapMode(maOriginalMapMode);
if(!renderChartPrimitive2D(
rChartPrimitive,
*mpOutputDevice,
getViewInformation2D()))
{
// fallback to decomposition (MetaFile)
process(rChartPrimitive.get2DDecomposition(getViewInformation2D()));
}
mpOutputDevice->Pop();
break;
}
case PRIMITIVE2D_ID_WRONGSPELLPRIMITIVE2D :
{
// wrong spell primitive. Handled directly here using VCL since VCL has a nice and
// very direct waveline painting which is needed for this. If VCL is to be avoided,
// this can be removed anytime and the decomposition may be used
const primitive2d::WrongSpellPrimitive2D& rWrongSpellPrimitive = static_cast< const primitive2d::WrongSpellPrimitive2D& >(rCandidate);
if(!renderWrongSpellPrimitive2D(
rWrongSpellPrimitive,
*mpOutputDevice,
getViewInformation2D().getObjectToViewTransformation(),
maBColorModifierStack))
{
// fallback to decomposition (MetaFile)
process(rWrongSpellPrimitive.get2DDecomposition(getViewInformation2D()));
}
break;
}
// nice to have:
//
// case PRIMITIVE2D_ID_CONTROLPRIMITIVE2D :
// - support FormControls more direct eventually, not sure if this is needed
// with the canvas renderer. The decomposition provides a bitmap representation
// of the control which will work
//
default :
{
// process recursively
process(rCandidate.get2DDecomposition(getViewInformation2D()));
break;
}
}
}
//////////////////////////////////////////////////////////////////////////////
// process support
canvasProcessor2D::canvasProcessor2D(
const geometry::ViewInformation2D& rViewInformation,
OutputDevice& rOutDev)
: BaseProcessor2D(rViewInformation),
maOriginalMapMode(rOutDev.GetMapMode()),
mpOutputDevice(&rOutDev),
mxCanvas(rOutDev.GetCanvas()),
maViewState(),
maRenderState(),
maBColorModifierStack(),
maDrawinglayerOpt(),
maClipPolyPolygon(),
meLang(drawinglayer::detail::getDigitLanguage())
{
canvas::tools::initViewState(maViewState);
canvas::tools::initRenderState(maRenderState);
canvas::tools::setViewStateTransform(maViewState, getViewInformation2D().getViewTransformation());
// set digit language, derived from SvtCTLOptions to have the correct
// number display for arabic/hindi numerals
rOutDev.SetDigitLanguage(meLang);
// 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);
}
}
canvasProcessor2D::~canvasProcessor2D()
{
// restore MapMode
mpOutputDevice->Pop();
// restore AntiAliasing
mpOutputDevice->SetAntialiasing(mpOutputDevice->GetAntialiasing() & ~ANTIALIASING_ENABLE_B2DDRAW);
}
} // end of namespace processor2d
} // end of namespace drawinglayer
//////////////////////////////////////////////////////////////////////////////
// eof
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */