| /************************************************************** | |
| * | |
| * 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_cppcanvas.hxx" | |
| #include <canvas/debug.hxx> | |
| #include <tools/diagnose_ex.h> | |
| #include <canvas/verbosetrace.hxx> | |
| #include <com/sun/star/rendering/RenderState.hpp> | |
| #include <com/sun/star/rendering/XCanvas.hpp> | |
| #include <basegfx/numeric/ftools.hxx> | |
| #include <basegfx/tools/canvastools.hxx> | |
| #include <basegfx/polygon/b2dpolygontools.hxx> | |
| #include <basegfx/polygon/b2dpolygon.hxx> | |
| #include <basegfx/range/b2drectangle.hxx> | |
| #include <basegfx/vector/b2dvector.hxx> | |
| #include <canvas/canvastools.hxx> | |
| #include <vcl/gdimtf.hxx> | |
| #include <vcl/metaact.hxx> | |
| #include <vcl/virdev.hxx> | |
| #include <vcl/metric.hxx> | |
| #include <tools/poly.hxx> | |
| #include "mtftools.hxx" | |
| #include "outdevstate.hxx" | |
| #include "polypolyaction.hxx" | |
| #include <basegfx/matrix/b2dhommatrixtools.hxx> | |
| using namespace ::com::sun::star; | |
| namespace cppcanvas | |
| { | |
| namespace tools | |
| { | |
| void initRenderState( rendering::RenderState& renderState, | |
| const ::cppcanvas::internal::OutDevState& outdevState ) | |
| { | |
| ::canvas::tools::initRenderState( renderState ); | |
| ::canvas::tools::setRenderStateTransform( renderState, | |
| outdevState.transform ); | |
| renderState.Clip = outdevState.xClipPoly; | |
| } | |
| ::Size getBaselineOffset( const ::cppcanvas::internal::OutDevState& outdevState, | |
| const VirtualDevice& rVDev ) | |
| { | |
| const ::FontMetric& aMetric = rVDev.GetFontMetric(); | |
| // calc offset for text output, the XCanvas always renders | |
| // baseline offset. | |
| switch( outdevState.textReferencePoint ) | |
| { | |
| case ALIGN_TOP: | |
| return ::Size( 0, | |
| aMetric.GetIntLeading() + aMetric.GetAscent() ); | |
| default: | |
| ENSURE_OR_THROW( false, | |
| "tools::getBaselineOffset(): Unexpected TextAlign value" ); | |
| // FALLTHROUGH intended (to calm compiler warning - case won't happen) | |
| case ALIGN_BASELINE: | |
| return ::Size( 0, 0 ); | |
| case ALIGN_BOTTOM: | |
| return ::Size( 0, | |
| -aMetric.GetDescent() ); | |
| } | |
| } | |
| ::basegfx::B2DHomMatrix& calcLogic2PixelLinearTransform( ::basegfx::B2DHomMatrix& o_rMatrix, | |
| const VirtualDevice& rVDev ) | |
| { | |
| // select size value in the middle of the available range, | |
| // to have headroom both when map mode scales up, and when | |
| // it scales down. | |
| const ::Size aSizeLogic( 0x00010000L, | |
| 0x00010000L ); | |
| const ::Size aSizePixel( rVDev.LogicToPixel( aSizeLogic ) ); | |
| o_rMatrix = basegfx::tools::createScaleB2DHomMatrix( | |
| aSizePixel.Width() / (double)aSizeLogic.Width(), | |
| aSizePixel.Height() / (double)aSizeLogic.Height() ); | |
| return o_rMatrix; | |
| } | |
| ::basegfx::B2DHomMatrix& calcLogic2PixelAffineTransform( ::basegfx::B2DHomMatrix& o_rMatrix, | |
| const VirtualDevice& rVDev ) | |
| { | |
| // retrieves scale | |
| calcLogic2PixelLinearTransform(o_rMatrix, rVDev); | |
| // translate according to curr map mode/pref map mode offset | |
| const ::Point aEmptyPoint; | |
| const ::Point& rTranslatedPoint( | |
| rVDev.LogicToPixel( aEmptyPoint )); | |
| o_rMatrix.translate(rTranslatedPoint.X(), | |
| rTranslatedPoint.Y()); | |
| return o_rMatrix; | |
| } | |
| bool modifyClip( rendering::RenderState& o_rRenderState, | |
| const struct ::cppcanvas::internal::OutDevState& rOutdevState, | |
| const CanvasSharedPtr& rCanvas, | |
| const ::basegfx::B2DPoint& rOffset, | |
| const ::basegfx::B2DVector* pScaling, | |
| const double* pRotation ) | |
| { | |
| const ::Point aEmptyPoint; | |
| const bool bOffsetting( !rOffset.equalZero() ); | |
| const bool bScaling( pScaling && | |
| pScaling->getX() != 1.0 && | |
| pScaling->getY() != 1.0 ); | |
| const bool bRotation( pRotation && | |
| *pRotation != 0.0 ); | |
| if( !bOffsetting && !bScaling && !bRotation ) | |
| return false; // nothing to do | |
| if( rOutdevState.clip.count() ) | |
| { | |
| // general polygon case | |
| ::basegfx::B2DPolyPolygon aLocalClip( rOutdevState.clip ); | |
| ::basegfx::B2DHomMatrix aTransform; | |
| if( bOffsetting ) | |
| aTransform.translate( -rOffset.getX(), | |
| -rOffset.getY() ); | |
| if( bScaling ) | |
| aTransform.scale( 1.0/pScaling->getX(), 1.0/pScaling->getY() ); | |
| if( bRotation ) | |
| aTransform.rotate( - *pRotation ); | |
| aLocalClip.transform( aTransform ); | |
| o_rRenderState.Clip = ::basegfx::unotools::xPolyPolygonFromB2DPolyPolygon( | |
| rCanvas->getUNOCanvas()->getDevice(), | |
| aLocalClip ); | |
| return true; | |
| } | |
| else if( !rOutdevState.clipRect.IsEmpty() ) | |
| { | |
| // simple rect case | |
| const ::Rectangle aLocalClipRect( rOutdevState.clipRect ); | |
| if( bRotation ) | |
| { | |
| // rotation involved - convert to polygon first, | |
| // then transform that | |
| ::basegfx::B2DPolygon aLocalClip( | |
| ::basegfx::tools::createPolygonFromRect( | |
| ::basegfx::B2DRectangle( | |
| (double)(aLocalClipRect.Left()), | |
| (double)(aLocalClipRect.Top()), | |
| (double)(aLocalClipRect.Right()), | |
| (double)(aLocalClipRect.Bottom()) ) ) ); | |
| ::basegfx::B2DHomMatrix aTransform; | |
| if( bOffsetting ) | |
| aTransform.translate( -rOffset.getX(), | |
| -rOffset.getY() ); | |
| if( bScaling ) | |
| aTransform.scale( 1.0/pScaling->getX(), 1.0/pScaling->getY() ); | |
| aTransform.rotate( - *pRotation ); | |
| aLocalClip.transform( aTransform ); | |
| o_rRenderState.Clip = ::basegfx::unotools::xPolyPolygonFromB2DPolyPolygon( | |
| rCanvas->getUNOCanvas()->getDevice(), | |
| ::basegfx::B2DPolyPolygon( aLocalClip ) ); | |
| } | |
| else if( bScaling ) | |
| { | |
| // scale and offset - do it on the fly, have to | |
| // convert to float anyway. | |
| o_rRenderState.Clip = ::basegfx::unotools::xPolyPolygonFromB2DPolyPolygon( | |
| rCanvas->getUNOCanvas()->getDevice(), | |
| ::basegfx::B2DPolyPolygon( | |
| ::basegfx::tools::createPolygonFromRect( | |
| ::basegfx::B2DRectangle( | |
| (double)(aLocalClipRect.Left() - rOffset.getX())/pScaling->getX(), | |
| (double)(aLocalClipRect.Top() - rOffset.getY())/pScaling->getY(), | |
| (double)(aLocalClipRect.Right() - rOffset.getX())/pScaling->getX(), | |
| (double)(aLocalClipRect.Bottom() - rOffset.getY())/pScaling->getY() ) ) ) ); | |
| } | |
| else | |
| { | |
| // offset only - do it on the fly, have to convert | |
| // to float anyway. | |
| o_rRenderState.Clip = ::basegfx::unotools::xPolyPolygonFromB2DPolyPolygon( | |
| rCanvas->getUNOCanvas()->getDevice(), | |
| ::basegfx::B2DPolyPolygon( | |
| ::basegfx::tools::createPolygonFromRect( | |
| ::basegfx::B2DRectangle( aLocalClipRect.Left() - rOffset.getX(), | |
| aLocalClipRect.Top() - rOffset.getY(), | |
| aLocalClipRect.Right() - rOffset.getX(), | |
| aLocalClipRect.Bottom() - rOffset.getY() ) ) ) ); | |
| } | |
| return true; | |
| } | |
| // empty clip, nothing to do | |
| return false; | |
| } | |
| bool modifyClip( rendering::RenderState& o_rRenderState, | |
| const struct ::cppcanvas::internal::OutDevState& rOutdevState, | |
| const CanvasSharedPtr& rCanvas, | |
| const ::Point& rOffset, | |
| const ::basegfx::B2DVector* pScaling, | |
| const double* pRotation ) | |
| { | |
| return modifyClip( o_rRenderState, | |
| rOutdevState, | |
| rCanvas, | |
| ::basegfx::B2DPoint( rOffset.X(), | |
| rOffset.Y() ), | |
| pScaling, | |
| pRotation ); | |
| } | |
| bool modifyClip( rendering::RenderState& o_rRenderState, | |
| const struct ::cppcanvas::internal::OutDevState& rOutdevState, | |
| const CanvasSharedPtr& rCanvas, | |
| const ::basegfx::B2DHomMatrix& rTransform ) | |
| { | |
| if( !rTransform.isIdentity() || | |
| !rTransform.isInvertible() ) | |
| return false; // nothing to do | |
| ::basegfx::B2DPolyPolygon aLocalClip; | |
| if( rOutdevState.clip.count() ) | |
| { | |
| aLocalClip = rOutdevState.clip; | |
| } | |
| else if( !rOutdevState.clipRect.IsEmpty() ) | |
| { | |
| const ::Rectangle aLocalClipRect( rOutdevState.clipRect ); | |
| aLocalClip = ::basegfx::B2DPolyPolygon( | |
| ::basegfx::tools::createPolygonFromRect( | |
| ::basegfx::B2DRectangle( | |
| aLocalClipRect.Left(), | |
| aLocalClipRect.Top(), | |
| aLocalClipRect.Right(), | |
| aLocalClipRect.Bottom() ) ) ); | |
| } | |
| else | |
| { | |
| // empty clip, nothing to do | |
| return false; | |
| } | |
| // invert transformation and modify | |
| ::basegfx::B2DHomMatrix aLocalTransform( rTransform ); | |
| aLocalTransform.invert(); | |
| aLocalClip.transform( aLocalTransform ); | |
| o_rRenderState.Clip = ::basegfx::unotools::xPolyPolygonFromB2DPolyPolygon( | |
| rCanvas->getUNOCanvas()->getDevice(), | |
| aLocalClip ); | |
| return true; | |
| } | |
| // create overline/underline/strikeout line info struct | |
| TextLineInfo createTextLineInfo( const ::VirtualDevice& rVDev, | |
| const ::cppcanvas::internal::OutDevState& rState ) | |
| { | |
| const sal_Bool bOldMode( rVDev.IsMapModeEnabled() ); | |
| // #i68512# Force metric regeneration with mapmode enabled | |
| // (prolly OutDev bug) | |
| rVDev.GetFontMetric(); | |
| // will restore map mode below | |
| const_cast< ::VirtualDevice& >(rVDev).EnableMapMode( sal_False ); | |
| const ::FontMetric aMetric = rVDev.GetFontMetric(); | |
| TextLineInfo aTextInfo( | |
| (aMetric.GetDescent() + 2) / 4.0, | |
| ((aMetric.GetIntLeading() + 1.5) / 3.0), | |
| (aMetric.GetIntLeading() / 2.0) - aMetric.GetAscent(), | |
| aMetric.GetDescent() / 2.0, | |
| (aMetric.GetIntLeading() - aMetric.GetAscent()) / 3.0, | |
| rState.textOverlineStyle, | |
| rState.textUnderlineStyle, | |
| rState.textStrikeoutStyle ); | |
| const_cast< ::VirtualDevice& >(rVDev).EnableMapMode( bOldMode ); | |
| return aTextInfo; | |
| } | |
| namespace | |
| { | |
| void appendRect( ::basegfx::B2DPolyPolygon& o_rPoly, | |
| const ::basegfx::B2DPoint& rStartPos, | |
| const double nX1, | |
| const double nY1, | |
| const double nX2, | |
| const double nY2 ) | |
| { | |
| const double x( rStartPos.getX() ); | |
| const double y( rStartPos.getY() ); | |
| o_rPoly.append( | |
| ::basegfx::tools::createPolygonFromRect( | |
| ::basegfx::B2DRectangle( x + nX1, y + nY1, x + nX2, y + nY2 ) ) ); | |
| } | |
| void appendRect( ::basegfx::B2DPolyPolygon& o_rPoly, | |
| const double nX1, | |
| const double nY1, | |
| const double nX2, | |
| const double nY2 ) | |
| { | |
| o_rPoly.append( | |
| ::basegfx::tools::createPolygonFromRect( | |
| ::basegfx::B2DRectangle( nX1, nY1, nX2, nY2 ) ) ); | |
| } | |
| void appendDashes( ::basegfx::B2DPolyPolygon& o_rPoly, | |
| const double nX, | |
| const double nY, | |
| const double nLineWidth, | |
| const double nLineHeight, | |
| const double nDashWidth, | |
| const double nDashSkip ) | |
| { | |
| const sal_Int32 nNumLoops( | |
| static_cast< sal_Int32 >( | |
| ::std::max( 1.0, | |
| nLineWidth / nDashSkip ) + .5) ); | |
| double x = nX; | |
| for( sal_Int32 i=0; i<nNumLoops; ++i ) | |
| { | |
| appendRect( o_rPoly, | |
| x, nY, | |
| x + nDashWidth, nY + nLineHeight ); | |
| x += nDashSkip; | |
| } | |
| } | |
| } | |
| // create line actions for text such as underline and | |
| // strikeout | |
| ::basegfx::B2DPolyPolygon createTextLinesPolyPolygon( const ::basegfx::B2DPoint rStartPos, | |
| const double& rLineWidth, | |
| const TextLineInfo& rTextLineInfo ) | |
| { | |
| // fill the polypolygon with all text lines | |
| ::basegfx::B2DPolyPolygon aTextLinesPolyPoly; | |
| switch( rTextLineInfo.mnOverlineStyle ) | |
| { | |
| case UNDERLINE_NONE: // nothing to do | |
| // FALLTHROUGH intended | |
| case UNDERLINE_DONTKNOW: | |
| break; | |
| case UNDERLINE_SMALLWAVE: // TODO(F3): NYI | |
| // FALLTHROUGH intended | |
| case UNDERLINE_WAVE: // TODO(F3): NYI | |
| // FALLTHROUGH intended | |
| case UNDERLINE_SINGLE: | |
| appendRect( | |
| aTextLinesPolyPoly, | |
| rStartPos, | |
| 0, | |
| rTextLineInfo.mnOverlineOffset, | |
| rLineWidth, | |
| rTextLineInfo.mnOverlineOffset + rTextLineInfo.mnOverlineHeight ); | |
| break; | |
| case UNDERLINE_BOLDDOTTED: // TODO(F3): NYI | |
| // FALLTHROUGH intended | |
| case UNDERLINE_BOLDDASH: // TODO(F3): NYI | |
| // FALLTHROUGH intended | |
| case UNDERLINE_BOLDLONGDASH: // TODO(F3): NYI | |
| // FALLTHROUGH intended | |
| case UNDERLINE_BOLDDASHDOT: // TODO(F3): NYI | |
| // FALLTHROUGH intended | |
| case UNDERLINE_BOLDDASHDOTDOT:// TODO(F3): NYI | |
| // FALLTHROUGH intended | |
| case UNDERLINE_BOLDWAVE: // TODO(F3): NYI | |
| // FALLTHROUGH intended | |
| case UNDERLINE_BOLD: | |
| appendRect( | |
| aTextLinesPolyPoly, | |
| rStartPos, | |
| 0, | |
| rTextLineInfo.mnOverlineOffset - rTextLineInfo.mnOverlineHeight, | |
| rLineWidth, | |
| rTextLineInfo.mnOverlineOffset + rTextLineInfo.mnOverlineHeight ); | |
| break; | |
| case UNDERLINE_DOUBLEWAVE: // TODO(F3): NYI | |
| // FALLTHROUGH intended | |
| case UNDERLINE_DOUBLE: | |
| appendRect( | |
| aTextLinesPolyPoly, | |
| rStartPos, | |
| 0, | |
| rTextLineInfo.mnOverlineOffset - rTextLineInfo.mnOverlineHeight * 2.0 , | |
| rLineWidth, | |
| rTextLineInfo.mnOverlineOffset - rTextLineInfo.mnOverlineHeight ); | |
| appendRect( | |
| aTextLinesPolyPoly, | |
| rStartPos, | |
| 0, | |
| rTextLineInfo.mnOverlineOffset + rTextLineInfo.mnOverlineHeight, | |
| rLineWidth, | |
| rTextLineInfo.mnOverlineOffset + rTextLineInfo.mnOverlineHeight * 2.0 ); | |
| break; | |
| case UNDERLINE_DASHDOTDOT: // TODO(F3): NYI | |
| // FALLTHROUGH intended | |
| case UNDERLINE_DOTTED: | |
| appendDashes( | |
| aTextLinesPolyPoly, | |
| rStartPos.getX(), | |
| rStartPos.getY() + rTextLineInfo.mnOverlineOffset, | |
| rLineWidth, | |
| rTextLineInfo.mnOverlineHeight, | |
| rTextLineInfo.mnOverlineHeight, | |
| 2*rTextLineInfo.mnOverlineHeight ); | |
| break; | |
| case UNDERLINE_DASHDOT: // TODO(F3): NYI | |
| // FALLTHROUGH intended | |
| case UNDERLINE_DASH: | |
| appendDashes( | |
| aTextLinesPolyPoly, | |
| rStartPos.getX(), | |
| rStartPos.getY() + rTextLineInfo.mnOverlineOffset, | |
| rLineWidth, | |
| rTextLineInfo.mnOverlineHeight, | |
| 3*rTextLineInfo.mnOverlineHeight, | |
| 6*rTextLineInfo.mnOverlineHeight ); | |
| break; | |
| case UNDERLINE_LONGDASH: | |
| appendDashes( | |
| aTextLinesPolyPoly, | |
| rStartPos.getX(), | |
| rStartPos.getY() + rTextLineInfo.mnOverlineOffset, | |
| rLineWidth, | |
| rTextLineInfo.mnOverlineHeight, | |
| 6*rTextLineInfo.mnOverlineHeight, | |
| 12*rTextLineInfo.mnOverlineHeight ); | |
| break; | |
| default: | |
| ENSURE_OR_THROW( false, | |
| "::cppcanvas::internal::createTextLinesPolyPolygon(): Unexpected overline case" ); | |
| } | |
| switch( rTextLineInfo.mnUnderlineStyle ) | |
| { | |
| case UNDERLINE_NONE: // nothing to do | |
| // FALLTHROUGH intended | |
| case UNDERLINE_DONTKNOW: | |
| break; | |
| case UNDERLINE_SMALLWAVE: // TODO(F3): NYI | |
| // FALLTHROUGH intended | |
| case UNDERLINE_WAVE: // TODO(F3): NYI | |
| // FALLTHROUGH intended | |
| case UNDERLINE_SINGLE: | |
| appendRect( | |
| aTextLinesPolyPoly, | |
| rStartPos, | |
| 0, | |
| rTextLineInfo.mnUnderlineOffset, | |
| rLineWidth, | |
| rTextLineInfo.mnUnderlineOffset + rTextLineInfo.mnLineHeight ); | |
| break; | |
| case UNDERLINE_BOLDDOTTED: // TODO(F3): NYI | |
| // FALLTHROUGH intended | |
| case UNDERLINE_BOLDDASH: // TODO(F3): NYI | |
| // FALLTHROUGH intended | |
| case UNDERLINE_BOLDLONGDASH: // TODO(F3): NYI | |
| // FALLTHROUGH intended | |
| case UNDERLINE_BOLDDASHDOT: // TODO(F3): NYI | |
| // FALLTHROUGH intended | |
| case UNDERLINE_BOLDDASHDOTDOT:// TODO(F3): NYI | |
| // FALLTHROUGH intended | |
| case UNDERLINE_BOLDWAVE: // TODO(F3): NYI | |
| // FALLTHROUGH intended | |
| case UNDERLINE_BOLD: | |
| appendRect( | |
| aTextLinesPolyPoly, | |
| rStartPos, | |
| 0, | |
| rTextLineInfo.mnUnderlineOffset, | |
| rLineWidth, | |
| rTextLineInfo.mnUnderlineOffset + 2*rTextLineInfo.mnLineHeight ); | |
| break; | |
| case UNDERLINE_DOUBLEWAVE: // TODO(F3): NYI | |
| // FALLTHROUGH intended | |
| case UNDERLINE_DOUBLE: | |
| appendRect( | |
| aTextLinesPolyPoly, | |
| rStartPos, | |
| 0, | |
| rTextLineInfo.mnUnderlineOffset - rTextLineInfo.mnLineHeight, | |
| rLineWidth, | |
| rTextLineInfo.mnUnderlineOffset ); | |
| appendRect( | |
| aTextLinesPolyPoly, | |
| rStartPos, | |
| 0, | |
| rTextLineInfo.mnUnderlineOffset + 2*rTextLineInfo.mnLineHeight, | |
| rLineWidth, | |
| rTextLineInfo.mnUnderlineOffset + 3*rTextLineInfo.mnLineHeight ); | |
| break; | |
| case UNDERLINE_DASHDOTDOT: // TODO(F3): NYI | |
| // FALLTHROUGH intended | |
| case UNDERLINE_DOTTED: | |
| appendDashes( | |
| aTextLinesPolyPoly, | |
| rStartPos.getX(), | |
| rStartPos.getY() + rTextLineInfo.mnUnderlineOffset, | |
| rLineWidth, | |
| rTextLineInfo.mnLineHeight, | |
| rTextLineInfo.mnLineHeight, | |
| 2*rTextLineInfo.mnLineHeight ); | |
| break; | |
| case UNDERLINE_DASHDOT: // TODO(F3): NYI | |
| // FALLTHROUGH intended | |
| case UNDERLINE_DASH: | |
| appendDashes( | |
| aTextLinesPolyPoly, | |
| rStartPos.getX(), | |
| rStartPos.getY() + rTextLineInfo.mnUnderlineOffset, | |
| rLineWidth, | |
| rTextLineInfo.mnLineHeight, | |
| 3*rTextLineInfo.mnLineHeight, | |
| 6*rTextLineInfo.mnLineHeight ); | |
| break; | |
| case UNDERLINE_LONGDASH: | |
| appendDashes( | |
| aTextLinesPolyPoly, | |
| rStartPos.getX(), | |
| rStartPos.getY() + rTextLineInfo.mnUnderlineOffset, | |
| rLineWidth, | |
| rTextLineInfo.mnLineHeight, | |
| 6*rTextLineInfo.mnLineHeight, | |
| 12*rTextLineInfo.mnLineHeight ); | |
| break; | |
| default: | |
| ENSURE_OR_THROW( false, | |
| "::cppcanvas::internal::createTextLinesPolyPolygon(): Unexpected underline case" ); | |
| } | |
| switch( rTextLineInfo.mnStrikeoutStyle ) | |
| { | |
| case STRIKEOUT_NONE: // nothing to do | |
| // FALLTHROUGH intended | |
| case STRIKEOUT_DONTKNOW: | |
| break; | |
| case STRIKEOUT_SLASH: // TODO(Q1): we should handle this in the text layer | |
| // FALLTHROUGH intended | |
| case STRIKEOUT_X: | |
| break; | |
| case STRIKEOUT_SINGLE: | |
| appendRect( | |
| aTextLinesPolyPoly, | |
| rStartPos, | |
| 0, | |
| rTextLineInfo.mnStrikeoutOffset, | |
| rLineWidth, | |
| rTextLineInfo.mnStrikeoutOffset + rTextLineInfo.mnLineHeight ); | |
| break; | |
| case STRIKEOUT_BOLD: | |
| appendRect( | |
| aTextLinesPolyPoly, | |
| rStartPos, | |
| 0, | |
| rTextLineInfo.mnStrikeoutOffset, | |
| rLineWidth, | |
| rTextLineInfo.mnStrikeoutOffset + 2*rTextLineInfo.mnLineHeight ); | |
| break; | |
| case STRIKEOUT_DOUBLE: | |
| appendRect( | |
| aTextLinesPolyPoly, | |
| rStartPos, | |
| 0, | |
| rTextLineInfo.mnStrikeoutOffset - rTextLineInfo.mnLineHeight, | |
| rLineWidth, | |
| rTextLineInfo.mnStrikeoutOffset ); | |
| appendRect( | |
| aTextLinesPolyPoly, | |
| rStartPos, | |
| 0, | |
| rTextLineInfo.mnStrikeoutOffset + 2*rTextLineInfo.mnLineHeight, | |
| rLineWidth, | |
| rTextLineInfo.mnStrikeoutOffset + 3*rTextLineInfo.mnLineHeight ); | |
| break; | |
| default: | |
| ENSURE_OR_THROW( false, | |
| "::cppcanvas::internal::createTextLinesPolyPolygon(): Unexpected strikeout case" ); | |
| } | |
| return aTextLinesPolyPoly; | |
| } | |
| ::basegfx::B2DRange calcDevicePixelBounds( const ::basegfx::B2DRange& rBounds, | |
| const rendering::ViewState& viewState, | |
| const rendering::RenderState& renderState ) | |
| { | |
| ::basegfx::B2DHomMatrix aTransform; | |
| ::canvas::tools::mergeViewAndRenderTransform( aTransform, | |
| viewState, | |
| renderState ); | |
| ::basegfx::B2DRange aTransformedBounds; | |
| return ::canvas::tools::calcTransformedRectBounds( aTransformedBounds, | |
| rBounds, | |
| aTransform ); | |
| } | |
| // create line actions for text such as underline and | |
| // strikeout | |
| ::basegfx::B2DPolyPolygon createTextLinesPolyPolygon( const double& rStartOffset, | |
| const double& rLineWidth, | |
| const TextLineInfo& rTextLineInfo ) | |
| { | |
| return createTextLinesPolyPolygon( | |
| ::basegfx::B2DPoint( rStartOffset, | |
| 0.0 ), | |
| rLineWidth, | |
| rTextLineInfo ); | |
| } | |
| } | |
| } |