Skip to content

C
core
Kaydet (Commit) 144eb666 authored tarafından Armin Le Grand's avatar Armin Le Grand
Dosyalara gözat
Seçenekler

i110384 added better fat line rendering where possible

üst be3f4139
Hide whitespace changes
Inline Side-by-side
Showing with 309 additions and 109 deletions
drawinglayer/inc/drawinglayer/processor2d/vclpixelprocessor2d.hxx
Dosyayı görüntüle @ 144eb666
......@@ -28,6 +28,15 @@
#include <drawinglayer/processor2d/vclprocessor2d.hxx>
#include <vcl/outdev.hxx>
//////////////////////////////////////////////////////////////////////////////
// predefines
namespace drawinglayer { namespace primitive2d {
class PolyPolygonColorPrimitive2D;
class PolygonHairlinePrimitive2D;
class PolygonStrokePrimitive2D;
}}
//////////////////////////////////////////////////////////////////////////////
namespace drawinglayer
......@@ -49,6 +58,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(
......
drawinglayer/inc/drawinglayer/processor2d/vclprocessor2d.hxx
Dosyayı görüntüle @ 144eb666
......@@ -41,7 +41,6 @@ namespace drawinglayer { namespace primitive2d {
class FillGraphicPrimitive2D;
class PolyPolygonGradientPrimitive2D;
class PolyPolygonGraphicPrimitive2D;
class PolyPolygonColorPrimitive2D;
class MetafilePrimitive2D;
class MaskPrimitive2D;
class UnifiedTransparencePrimitive2D;
......@@ -98,7 +97,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);
......
drawinglayer/source/processor2d/vclpixelprocessor2d.cxx
Dosyayı görüntüle @ 144eb666
......@@ -99,6 +99,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())
......@@ -176,8 +311,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 :
......@@ -247,8 +391,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 :
......@@ -320,25 +509,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;
//}
}
}
}
......@@ -438,6 +643,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
......@@ -466,9 +679,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
......
drawinglayer/source/processor2d/vclprocessor2d.cxx
Dosyayı görüntüle @ 144eb666
......@@ -756,86 +756,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)
{
......
vcl/inc/vcl/outdev.hxx
Dosyayı görüntüle @ 144eb666
......@@ -562,6 +562,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);
......@@ -699,6 +700,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
......
vcl/source/gdi/outdev.cxx
Dosyayı görüntüle @ 144eb666
......@@ -2260,6 +2260,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)
{
......@@ -2289,13 +2290,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,
......@@ -2304,8 +2356,6 @@ void OutputDevice::DrawPolyLine(
{
DBG_TRACE( "OutputDevice::DrawPolyLine(B2D&)" );
DBG_CHKTHIS( OutputDevice, ImplDbgCheckOutputDevice );
(void)eLineJoin; // ATM used in UNX, but not in WNT, access it for warning-free
(void)eLineCap;
#if 0 // MetaB2DPolyLineAction is not implemented yet:
// according to AW adding it is very dangerous since there is a lot
......@@ -2347,7 +2397,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;
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment