mir/libreoffice
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Resolves: #i110384# added better fat line rendering where possible

Browse Source 
(cherry picked from commit 144eb666b72516ef78c15424087800dff1be5cfd)

Conflicts:
	drawinglayer/inc/drawinglayer/processor2d/vclpixelprocessor2d.hxx
	drawinglayer/inc/drawinglayer/processor2d/vclprocessor2d.hxx
	vcl/inc/vcl/outdev.hxx

Change-Id: I89f378a4d7a8311b8922f10acff66b000a20a4b7
This commit is contained in:
Armin Le Grand
2013-05-10 08:48:11 +00:00
committed by Caolán McNamara
parent 5e5f3671f8
commit 02da9f7a91
6 changed files with 309 additions and 109 deletions
Download Patch File Download Diff File Expand all files Collapse all files

257
drawinglayer/source/processor2d/vclpixelprocessor2d.cxx
View File

@@ -92,6 +92,141 @@ namespace drawinglayer
mpOutputDevice->SetAntialiasing(mpOutputDevice->GetAntialiasing() & ~ANTIALIASING_ENABLE_B2DDRAW);
}
bool VclPixelProcessor2D::tryDrawPolyPolygonColorPrimitive2DDirect(const drawinglayer::primitive2d::PolyPolygonColorPrimitive2D& rSource, double fTransparency)
{
basegfx::B2DPolyPolygon aLocalPolyPolygon(rSource.getB2DPolyPolygon());
if(!aLocalPolyPolygon.count())
{
// no geometry, done
return true;
}
const basegfx::BColor aPolygonColor(maBColorModifierStack.getModifiedColor(rSource.getBColor()));
mpOutputDevice->SetFillColor(Color(aPolygonColor));
mpOutputDevice->SetLineColor();
aLocalPolyPolygon.transform(maCurrentTransformation);
mpOutputDevice->DrawTransparent(
aLocalPolyPolygon,
fTransparency);
return true;
}
bool VclPixelProcessor2D::tryDrawPolygonHairlinePrimitive2DDirect(const drawinglayer::primitive2d::PolygonHairlinePrimitive2D& rSource, double fTransparency)
{
basegfx::B2DPolygon aLocalPolygon(rSource.getB2DPolygon());
if(!aLocalPolygon.count())
{
// no geometry, done
return true;
}
const basegfx::BColor aLineColor(maBColorModifierStack.getModifiedColor(rSource.getBColor()));
mpOutputDevice->SetFillColor();
mpOutputDevice->SetLineColor(Color(aLineColor));
aLocalPolygon.transform(maCurrentTransformation);
// try drawing; if it did not work, use standard fallback
if(mpOutputDevice->TryDrawPolyLineDirect(
aLocalPolygon,
0.0,
fTransparency))
{
return true;
}
return false;
}
bool VclPixelProcessor2D::tryDrawPolygonStrokePrimitive2DDirect(const drawinglayer::primitive2d::PolygonStrokePrimitive2D& rSource, double fTransparency)
{
basegfx::B2DPolygon aLocalPolygon(rSource.getB2DPolygon());
if(!aLocalPolygon.count())
{
// no geometry, done
return true;
}
aLocalPolygon = basegfx::tools::simplifyCurveSegments(aLocalPolygon);
basegfx::B2DPolyPolygon aHairLinePolyPolygon;
if(rSource.getStrokeAttribute().isDefault() || 0.0 == rSource.getStrokeAttribute().getFullDotDashLen())
{
// no line dashing, just copy
aHairLinePolyPolygon.append(aLocalPolygon);
}
else
{
// apply LineStyle
basegfx::tools::applyLineDashing(
aLocalPolygon,
rSource.getStrokeAttribute().getDotDashArray(),
&aHairLinePolyPolygon,
0,
rSource.getStrokeAttribute().getFullDotDashLen());
}
if(!aHairLinePolyPolygon.count())
{
// no geometry, done
return true;
}
const basegfx::BColor aLineColor(
maBColorModifierStack.getModifiedColor(
rSource.getLineAttribute().getColor()));
mpOutputDevice->SetFillColor();
mpOutputDevice->SetLineColor(Color(aLineColor));
aHairLinePolyPolygon.transform(maCurrentTransformation);
double fLineWidth(rSource.getLineAttribute().getWidth());
if(basegfx::fTools::more(fLineWidth, 0.0))
{
basegfx::B2DVector aLineWidth(fLineWidth, 0.0);
aLineWidth = maCurrentTransformation * aLineWidth;
fLineWidth = aLineWidth.getLength();
}
bool bHasPoints(false);
bool bTryWorked(false);
for(sal_uInt32 a(0); a < aHairLinePolyPolygon.count(); a++)
{
const basegfx::B2DPolygon aSingle(aHairLinePolyPolygon.getB2DPolygon(a));
if(aSingle.count())
{
bHasPoints = true;
if(mpOutputDevice->TryDrawPolyLineDirect(
aSingle,
fLineWidth,
fTransparency,
rSource.getLineAttribute().getLineJoin(),
rSource.getLineAttribute().getLineCap()))
{
bTryWorked = true;
}
}
}
if(!bTryWorked && !bHasPoints)
{
// no geometry despite try
bTryWorked = true;
}
return bTryWorked;
}
void VclPixelProcessor2D::processBasePrimitive2D(const primitive2d::BasePrimitive2D& rCandidate)
{
switch(rCandidate.getPrimitive2DID())
@@ -169,8 +304,17 @@ namespace drawinglayer
}
case PRIMITIVE2D_ID_POLYGONHAIRLINEPRIMITIVE2D :
{
// try to use directly
const primitive2d::PolygonHairlinePrimitive2D& rPolygonHairlinePrimitive2D = static_cast< const primitive2d::PolygonHairlinePrimitive2D& >(rCandidate);
static bool bAllowed(true);
if(bAllowed && tryDrawPolygonHairlinePrimitive2DDirect(rPolygonHairlinePrimitive2D, 0.0))
{
break;
}
// direct draw of hairline
RenderPolygonHairlinePrimitive2D(static_cast< const primitive2d::PolygonHairlinePrimitive2D& >(rCandidate), true);
RenderPolygonHairlinePrimitive2D(rPolygonHairlinePrimitive2D, true);
break;
}
case PRIMITIVE2D_ID_BITMAPPRIMITIVE2D :
@@ -240,8 +384,53 @@ namespace drawinglayer
}
case PRIMITIVE2D_ID_POLYPOLYGONCOLORPRIMITIVE2D :
{
// direct draw of PolyPolygon with color
RenderPolyPolygonColorPrimitive2D(static_cast< const primitive2d::PolyPolygonColorPrimitive2D& >(rCandidate));
// try to use directly
const primitive2d::PolyPolygonColorPrimitive2D& rPolyPolygonColorPrimitive2D = static_cast< const primitive2d::PolyPolygonColorPrimitive2D& >(rCandidate);
basegfx::B2DPolyPolygon aLocalPolyPolygon;
static bool bAllowed(true);
if(bAllowed && tryDrawPolyPolygonColorPrimitive2DDirect(rPolyPolygonColorPrimitive2D, 0.0))
{
// okay, done. In this case no gaps should have to be repaired, too
}
else
{
// direct draw of PolyPolygon with color
const basegfx::BColor aPolygonColor(maBColorModifierStack.getModifiedColor(rPolyPolygonColorPrimitive2D.getBColor()));
mpOutputDevice->SetFillColor(Color(aPolygonColor));
mpOutputDevice->SetLineColor();
aLocalPolyPolygon = rPolyPolygonColorPrimitive2D.getB2DPolyPolygon();
aLocalPolyPolygon.transform(maCurrentTransformation);
mpOutputDevice->DrawPolyPolygon(aLocalPolyPolygon);
}
// when AA is on and this filled polygons are the result of stroked line geometry,
// draw the geometry once extra as lines to avoid AA 'gaps' between partial polygons
// Caution: This is needed in both cases (!)
if(mnPolygonStrokePrimitive2D
&& getOptionsDrawinglayer().IsAntiAliasing()
&& (mpOutputDevice->GetAntialiasing() & ANTIALIASING_ENABLE_B2DDRAW))
{
const basegfx::BColor aPolygonColor(maBColorModifierStack.getModifiedColor(rPolyPolygonColorPrimitive2D.getBColor()));
sal_uInt32 nCount(aLocalPolyPolygon.count());
if(!nCount)
{
aLocalPolyPolygon = rPolyPolygonColorPrimitive2D.getB2DPolyPolygon();
aLocalPolyPolygon.transform(maCurrentTransformation);
nCount = aLocalPolyPolygon.count();
}
mpOutputDevice->SetFillColor();
mpOutputDevice->SetLineColor(Color(aPolygonColor));
for(sal_uInt32 a(0); a < nCount; a++)
{
mpOutputDevice->DrawPolyLine(aLocalPolyPolygon.getB2DPolygon(a), 0.0);
}
}
break;
}
case PRIMITIVE2D_ID_METAFILEPRIMITIVE2D :
@@ -313,25 +502,41 @@ namespace drawinglayer
// 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;
bDrawTransparentUsed = tryDrawPolyPolygonColorPrimitive2DDirect(*pPoPoColor, rUniTransparenceCandidate.getTransparence());
break;
}
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 (!)");
// do no tallow by default - problem is that self-overlapping parts of this geometry will
// not be in a all-same transparency but will already alpha-cover themselves with blending.
// This is not what the UnifiedTransparencePrimitive2D defines: It requires all it's
// content to be uniformely transparent.
// For hairline the effect is pretty minimal, but still not correct.
static bool bAllowed(false);
bDrawTransparentUsed = bAllowed && tryDrawPolygonHairlinePrimitive2DDirect(*pPoHair, rUniTransparenceCandidate.getTransparence());
break;
}
case PRIMITIVE2D_ID_POLYGONSTROKEPRIMITIVE2D:
{
// single transparent PolygonStrokePrimitive2D identified, use directly
const primitive2d::PolygonStrokePrimitive2D* pPoStroke = static_cast< const primitive2d::PolygonStrokePrimitive2D* >(pBasePrimitive);
OSL_ENSURE(pPoStroke, "OOps, PrimitiveID and PrimitiveType do not match (!)");
// do no tallow by default - problem is that self-overlapping parts of this geometry will
// not be in a all-same transparency but will already alpha-cover themselves with blending.
// This is not what the UnifiedTransparencePrimitive2D defines: It requires all it's
// content to be uniformely transparent.
// To check, acitvate and draw a wide transparent self-crossing line/curve
static bool bAllowed(false);
bDrawTransparentUsed = bAllowed && tryDrawPolygonStrokePrimitive2DDirect(*pPoStroke, rUniTransparenceCandidate.getTransparence());
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;
//}
}
}
}
@@ -431,6 +636,14 @@ namespace drawinglayer
}
case PRIMITIVE2D_ID_POLYGONSTROKEPRIMITIVE2D:
{
// try to use directly
const primitive2d::PolygonStrokePrimitive2D& rPolygonStrokePrimitive2D = static_cast< const primitive2d::PolygonStrokePrimitive2D& >(rCandidate);
if(tryDrawPolygonStrokePrimitive2DDirect(rPolygonStrokePrimitive2D, 0.0))
{
break;
}
// 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
@@ -459,9 +672,7 @@ namespace drawinglayer
// 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);
RenderPolygonStrokePrimitive2D(rPolygonStrokePrimitive2D);
}
// restore DrawMode

14
drawinglayer/source/processor2d/vclpixelprocessor2d.hxx
View File

@@ -25,6 +25,15 @@
#include "vclprocessor2d.hxx"
#include <vcl/outdev.hxx>
//////////////////////////////////////////////////////////////////////////////
// predefines
namespace drawinglayer { namespace primitive2d {
class PolyPolygonColorPrimitive2D;
class PolygonHairlinePrimitive2D;
class PolygonStrokePrimitive2D;
}}
//////////////////////////////////////////////////////////////////////////////
namespace drawinglayer
@@ -46,6 +55,11 @@ namespace drawinglayer
*/
virtual void processBasePrimitive2D(const primitive2d::BasePrimitive2D& rCandidate);
// some helpers to try direct paints (shortcuts)
bool tryDrawPolyPolygonColorPrimitive2DDirect(const drawinglayer::primitive2d::PolyPolygonColorPrimitive2D& rSource, double fTransparency);
bool tryDrawPolygonHairlinePrimitive2DDirect(const drawinglayer::primitive2d::PolygonHairlinePrimitive2D& rSource, double fTransparency);
bool tryDrawPolygonStrokePrimitive2DDirect(const drawinglayer::primitive2d::PolygonStrokePrimitive2D& rSource, double fTransparency);
public:
/// constructor/destructor
VclPixelProcessor2D(

80
drawinglayer/source/processor2d/vclprocessor2d.cxx
View File

@@ -782,86 +782,6 @@ namespace drawinglayer
}
}
// direct draw of PolyPolygon with color
void VclProcessor2D::RenderPolyPolygonColorPrimitive2D(const primitive2d::PolyPolygonColorPrimitive2D& rPolygonCandidate)
{
const basegfx::BColor aPolygonColor(maBColorModifierStack.getModifiedColor(rPolygonCandidate.getBColor()));
mpOutputDevice->SetFillColor(Color(aPolygonColor));
mpOutputDevice->SetLineColor();
basegfx::B2DPolyPolygon aLocalPolyPolygon(rPolygonCandidate.getB2DPolyPolygon());
aLocalPolyPolygon.transform(maCurrentTransformation);
static bool bCheckTrapezoidDecomposition(false);
static bool bShowOutlinesThere(false);
if(bCheckTrapezoidDecomposition)
{
// clip against discrete ViewPort
const basegfx::B2DRange& rDiscreteViewport = getViewInformation2D().getDiscreteViewport();
aLocalPolyPolygon = basegfx::tools::clipPolyPolygonOnRange(
aLocalPolyPolygon, rDiscreteViewport, true, false);
if(aLocalPolyPolygon.count())
{
// subdivide
aLocalPolyPolygon = basegfx::tools::adaptiveSubdivideByDistance(
aLocalPolyPolygon, 0.5);
// trapezoidize
basegfx::B2DTrapezoidVector aB2DTrapezoidVector;
basegfx::tools::trapezoidSubdivide(aB2DTrapezoidVector, aLocalPolyPolygon);
const sal_uInt32 nCount(aB2DTrapezoidVector.size());
if(nCount)
{
basegfx::BColor aInvPolygonColor(aPolygonColor);
aInvPolygonColor.invert();
for(sal_uInt32 a(0); a < nCount; a++)
{
const basegfx::B2DPolygon aTempPolygon(aB2DTrapezoidVector[a].getB2DPolygon());
if(bShowOutlinesThere)
{
mpOutputDevice->SetFillColor(Color(aPolygonColor));
mpOutputDevice->SetLineColor();
}
mpOutputDevice->DrawPolygon(aTempPolygon);
if(bShowOutlinesThere)
{
mpOutputDevice->SetFillColor();
mpOutputDevice->SetLineColor(Color(aInvPolygonColor));
mpOutputDevice->DrawPolyLine(aTempPolygon, 0.0);
}
}
}
}
}
else
{
mpOutputDevice->DrawPolyPolygon(aLocalPolyPolygon);
if(mnPolygonStrokePrimitive2D
&& getOptionsDrawinglayer().IsAntiAliasing()
&& (mpOutputDevice->GetAntialiasing() & ANTIALIASING_ENABLE_B2DDRAW))
{
// when AA is on and this filled polygons are the result of stroked line geometry,
// draw the geometry once extra as lines to avoid AA 'gaps' between partial polygons
mpOutputDevice->SetFillColor();
mpOutputDevice->SetLineColor(Color(aPolygonColor));
const sal_uInt32 nCount(aLocalPolyPolygon.count());
for(sal_uInt32 a(0); a < nCount; a++)
{
mpOutputDevice->DrawPolyLine(aLocalPolyPolygon.getB2DPolygon(a), 0.0);
}
}
}
}
// mask group. Force output to VDev and create mask from given mask
void VclProcessor2D::RenderMaskPrimitive2DPixel(const primitive2d::MaskPrimitive2D& rMaskCandidate)
{

2
drawinglayer/source/processor2d/vclprocessor2d.hxx
View File

@@ -38,7 +38,6 @@ namespace drawinglayer { namespace primitive2d {
class FillGraphicPrimitive2D;
class PolyPolygonGradientPrimitive2D;
class PolyPolygonGraphicPrimitive2D;
class PolyPolygonColorPrimitive2D;
class MetafilePrimitive2D;
class MaskPrimitive2D;
class UnifiedTransparencePrimitive2D;
@@ -95,7 +94,6 @@ namespace drawinglayer
void RenderBitmapPrimitive2D(const primitive2d::BitmapPrimitive2D& rBitmapCandidate);
void RenderFillGraphicPrimitive2D(const primitive2d::FillGraphicPrimitive2D& rFillBitmapCandidate);
void RenderPolyPolygonGraphicPrimitive2D(const primitive2d::PolyPolygonGraphicPrimitive2D& rPolygonCandidate);
void RenderPolyPolygonColorPrimitive2D(const primitive2d::PolyPolygonColorPrimitive2D& rPolygonCandidate);
void RenderMaskPrimitive2DPixel(const primitive2d::MaskPrimitive2D& rMaskCandidate);
void RenderModifiedColorPrimitive2D(const primitive2d::ModifiedColorPrimitive2D& rModifiedCandidate);
void RenderUnifiedTransparencePrimitive2D(const primitive2d::UnifiedTransparencePrimitive2D& rTransCandidate);

7
include/vcl/outdev.hxx
View File

@@ -534,6 +534,7 @@ public:
SAL_DLLPRIVATE bool ImpTryDrawPolyLineDirect(
const basegfx::B2DPolygon& rB2DPolygon,
double fLineWidth = 0.0,
double fTransparency = 0.0,
basegfx::B2DLineJoin eLineJoin = basegfx::B2DLINEJOIN_NONE,
com::sun::star::drawing::LineCap eLineCap = com::sun::star::drawing::LineCap_BUTT);
@@ -673,6 +674,12 @@ public:
double fLineWidth = 0.0,
basegfx::B2DLineJoin = basegfx::B2DLINEJOIN_ROUND,
com::sun::star::drawing::LineCap = com::sun::star::drawing::LineCap_BUTT);
bool TryDrawPolyLineDirect(
const basegfx::B2DPolygon& rB2DPolygon,
double fLineWidth = 0.0,
double fTransparency = 0.0,
basegfx::B2DLineJoin eLineJoin = basegfx::B2DLINEJOIN_NONE,
com::sun::star::drawing::LineCap eLineCap = com::sun::star::drawing::LineCap_BUTT);
/** Render the given polygon as a line stroke

58
vcl/source/gdi/outdev.cxx
View File

@@ -2148,6 +2148,7 @@ void OutputDevice::ImpDrawPolyPolygonWithB2DPolyPolygon(const basegfx::B2DPolyPo
bool OutputDevice::ImpTryDrawPolyLineDirect(
const basegfx::B2DPolygon& rB2DPolygon,
double fLineWidth,
double fTransparency,
basegfx::B2DLineJoin eLineJoin,
com::sun::star::drawing::LineCap eLineCap)
{
@@ -2177,13 +2178,64 @@ bool OutputDevice::ImpTryDrawPolyLineDirect(
// draw the polyline
return mpGraphics->DrawPolyLine(
aB2DPolygon,
0.0,
fTransparency,
aB2DLineWidth,
eLineJoin,
eLineCap,
this);
}
bool OutputDevice::TryDrawPolyLineDirect(
const basegfx::B2DPolygon& rB2DPolygon,
double fLineWidth,
double fTransparency,
basegfx::B2DLineJoin eLineJoin,
com::sun::star::drawing::LineCap eLineCap)
{
// AW: Do NOT paint empty PolyPolygons
if(!rB2DPolygon.count())
return true;
// we need a graphics
if( !mpGraphics )
if( !ImplGetGraphics() )
return false;
if( mbInitClipRegion )
ImplInitClipRegion();
if( mbOutputClipped )
return true;
if( mbInitLineColor )
ImplInitLineColor();
const bool bTryAA((mnAntialiasing & ANTIALIASING_ENABLE_B2DDRAW)
&& mpGraphics->supportsOperation(OutDevSupport_B2DDraw)
&& ROP_OVERPAINT == GetRasterOp()
&& IsLineColor());
if(bTryAA)
{
if(ImpTryDrawPolyLineDirect(rB2DPolygon, fLineWidth, fTransparency, eLineJoin, eLineCap))
{
// worked, add metafile action (if recorded) and return true
if( mpMetaFile )
{
LineInfo aLineInfo;
if( fLineWidth != 0.0 )
aLineInfo.SetWidth( static_cast<long>(fLineWidth+0.5) );
const Polygon aToolsPolygon( rB2DPolygon );
mpMetaFile->AddAction( new MetaPolyLineAction( aToolsPolygon, aLineInfo ) );
}
return true;
}
}
return false;
}
void OutputDevice::DrawPolyLine(
const basegfx::B2DPolygon& rB2DPolygon,
double fLineWidth,
@@ -2191,8 +2243,6 @@ void OutputDevice::DrawPolyLine(
com::sun::star::drawing::LineCap eLineCap)
{
DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice );
(void)eLineJoin; // ATM used in UNX, but not in WNT, access it for warning-free
(void)eLineCap;
if( mpMetaFile )
{
@@ -2226,7 +2276,7 @@ void OutputDevice::DrawPolyLine(
&& IsLineColor());
// use b2dpolygon drawing if possible
if(bTryAA && ImpTryDrawPolyLineDirect(rB2DPolygon, fLineWidth, eLineJoin, eLineCap))
if(bTryAA && ImpTryDrawPolyLineDirect(rB2DPolygon, fLineWidth, 0.0, eLineJoin, eLineCap))
{
return;
}