2006-10-19 09:40:02 +00:00
|
|
|
/*************************************************************************
|
|
|
|
|
*
|
|
|
|
|
* OpenOffice.org - a multi-platform office productivity suite
|
|
|
|
|
*
|
|
|
|
|
* $RCSfile: vclprocessor2d.cxx,v $
|
|
|
|
|
*
|
2008-06-24 14:31:09 +00:00
|
|
|
* $Revision: 1.31 $
|
2006-10-19 09:40:02 +00:00
|
|
|
*
|
2008-06-24 14:31:09 +00:00
|
|
|
* last change: $Author: aw $ $Date: 2008-06-24 15:31:09 $
|
2006-10-19 09:40:02 +00:00
|
|
|
*
|
|
|
|
|
* The Contents of this file are made available subject to
|
|
|
|
|
* the terms of GNU Lesser General Public License Version 2.1.
|
|
|
|
|
*
|
|
|
|
|
*
|
|
|
|
|
* GNU Lesser General Public License Version 2.1
|
|
|
|
|
* =============================================
|
|
|
|
|
* Copyright 2005 by Sun Microsystems, Inc.
|
|
|
|
|
* 901 San Antonio Road, Palo Alto, CA 94303, USA
|
|
|
|
|
*
|
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
|
* License version 2.1, as published by the Free Software Foundation.
|
|
|
|
|
*
|
|
|
|
|
* This library 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 for more details.
|
|
|
|
|
*
|
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
|
|
|
* License along with this library; if not, write to the Free Software
|
|
|
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
|
|
|
|
|
* MA 02111-1307 USA
|
|
|
|
|
*
|
|
|
|
|
************************************************************************/
|
|
|
|
|
|
2008-03-05 08:18:45 +00:00
|
|
|
// MARKER(update_precomp.py): autogen include statement, do not remove
|
|
|
|
|
#include "precompiled_drawinglayer.hxx"
|
|
|
|
|
|
2006-10-19 09:40:02 +00:00
|
|
|
#include <drawinglayer/processor2d/vclprocessor2d.hxx>
|
2007-03-06 11:36:13 +00:00
|
|
|
#include <drawinglayer/primitive2d/textprimitive2d.hxx>
|
2007-08-02 10:43:45 +00:00
|
|
|
#include <drawinglayer/primitive2d/textdecoratedprimitive2d.hxx>
|
2007-07-27 08:04:00 +00:00
|
|
|
#include <tools/debug.hxx>
|
2006-10-19 09:40:02 +00:00
|
|
|
#include <vcl/outdev.hxx>
|
2007-03-06 11:36:13 +00:00
|
|
|
#include <drawinglayer/primitive2d/polygonprimitive2d.hxx>
|
|
|
|
|
#include <drawinglayer/primitive2d/bitmapprimitive2d.hxx>
|
|
|
|
|
#include <vclhelperbitmaptransform.hxx>
|
2006-10-19 09:40:02 +00:00
|
|
|
#include <basegfx/polygon/b2dpolygontools.hxx>
|
2007-03-06 11:36:13 +00:00
|
|
|
#include <vclhelperbitmaprender.hxx>
|
2006-10-19 09:40:02 +00:00
|
|
|
#include <drawinglayer/attribute/sdrfillbitmapattribute.hxx>
|
|
|
|
|
#include <drawinglayer/primitive2d/fillbitmapprimitive2d.hxx>
|
2007-03-06 11:36:13 +00:00
|
|
|
#include <drawinglayer/attribute/fillattribute.hxx>
|
2006-10-19 09:40:02 +00:00
|
|
|
#include <drawinglayer/primitive2d/polypolygonprimitive2d.hxx>
|
2007-03-06 11:36:13 +00:00
|
|
|
#include <vclhelpergradient.hxx>
|
|
|
|
|
#include <drawinglayer/primitive2d/metafileprimitive2d.hxx>
|
2006-10-19 09:40:02 +00:00
|
|
|
#include <drawinglayer/primitive2d/maskprimitive2d.hxx>
|
2007-03-06 11:36:13 +00:00
|
|
|
#include <basegfx/polygon/b2dpolypolygontools.hxx>
|
|
|
|
|
#include <vclhelperbufferdevice.hxx>
|
|
|
|
|
#include <drawinglayer/primitive2d/modifiedcolorprimitive2d.hxx>
|
2006-10-19 09:40:02 +00:00
|
|
|
#include <drawinglayer/primitive2d/alphaprimitive2d.hxx>
|
|
|
|
|
#include <drawinglayer/primitive2d/transformprimitive2d.hxx>
|
2007-01-25 17:21:36 +00:00
|
|
|
#include <drawinglayer/primitive2d/markerarrayprimitive2d.hxx>
|
2007-07-27 08:04:00 +00:00
|
|
|
#include <drawinglayer/primitive2d/pointarrayprimitive2d.hxx>
|
2007-09-20 08:51:46 +00:00
|
|
|
#include <drawinglayer/primitive2d/wrongspellprimitive2d.hxx>
|
2007-10-02 15:55:00 +00:00
|
|
|
#include <svtools/ctloptions.hxx>
|
|
|
|
|
#include <vcl/svapp.hxx>
|
2008-02-07 12:42:32 +00:00
|
|
|
#include <drawinglayer/primitive2d/pagepreviewprimitive2d.hxx>
|
|
|
|
|
|
2006-10-19 09:40:02 +00:00
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
2007-10-15 15:11:08 +00:00
|
|
|
// control support
|
2006-10-19 09:40:02 +00:00
|
|
|
|
2007-10-15 15:11:08 +00:00
|
|
|
#include <com/sun/star/awt/XWindow2.hpp>
|
|
|
|
|
#include <com/sun/star/awt/PosSize.hpp>
|
|
|
|
|
#include <com/sun/star/awt/XView.hpp>
|
|
|
|
|
#include <drawinglayer/primitive2d/controlprimitive2d.hxx>
|
2007-11-19 09:21:42 +00:00
|
|
|
#include <drawinglayer/primitive2d/textlayoutdevice.hxx>
|
|
|
|
|
|
2007-12-03 12:54:35 +00:00
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
// for test, can be removed again
|
|
|
|
|
|
|
|
|
|
#include <basegfx/polygon/b2dpolygonclipper.hxx>
|
|
|
|
|
|
2006-10-19 09:40:02 +00:00
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
2008-02-07 12:42:32 +00:00
|
|
|
using namespace com::sun::star;
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
2006-10-19 09:40:02 +00:00
|
|
|
namespace drawinglayer
|
|
|
|
|
{
|
|
|
|
|
namespace processor2d
|
|
|
|
|
{
|
2007-10-15 15:11:08 +00:00
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
2007-11-19 09:21:42 +00:00
|
|
|
// UNO class usages
|
2007-10-15 15:11:08 +00:00
|
|
|
using ::com::sun::star::uno::Reference;
|
|
|
|
|
using ::com::sun::star::uno::UNO_QUERY;
|
|
|
|
|
using ::com::sun::star::uno::UNO_QUERY_THROW;
|
|
|
|
|
using ::com::sun::star::awt::XView;
|
|
|
|
|
using ::com::sun::star::awt::XGraphics;
|
|
|
|
|
using ::com::sun::star::awt::XWindow;
|
|
|
|
|
using ::com::sun::star::awt::PosSize::POSSIZE;
|
|
|
|
|
|
2006-10-19 09:40:02 +00:00
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
// rendering support
|
|
|
|
|
|
2007-07-09 12:19:09 +00:00
|
|
|
// directdraw of text simple portion or decorated portion primitive. When decorated, all the extra
|
|
|
|
|
// information is translated to VCL parameters and set at the font.
|
|
|
|
|
// Acceptance is restricted to no shearing and positive scaling in X and Y (no font mirroring
|
|
|
|
|
// for VCL)
|
|
|
|
|
void VclProcessor2D::RenderTextSimpleOrDecoratedPortionPrimitive2D(const primitive2d::TextSimplePortionPrimitive2D& rTextCandidate)
|
2006-10-19 09:40:02 +00:00
|
|
|
{
|
|
|
|
|
// decompose matrix to have position and size of text
|
|
|
|
|
basegfx::B2DHomMatrix aLocalTransform(maCurrentTransformation * rTextCandidate.getTextTransform());
|
|
|
|
|
basegfx::B2DVector aScale, aTranslate;
|
|
|
|
|
double fRotate, fShearX;
|
|
|
|
|
aLocalTransform.decompose(aScale, aTranslate, fRotate, fShearX);
|
|
|
|
|
bool bPrimitiveAccepted(false);
|
|
|
|
|
|
|
|
|
|
if(basegfx::fTools::equalZero(fShearX))
|
|
|
|
|
{
|
|
|
|
|
if(basegfx::fTools::less(aScale.getX(), 0.0) && basegfx::fTools::less(aScale.getY(), 0.0))
|
|
|
|
|
{
|
|
|
|
|
// handle special case: If scale is negative in (x,y) (3rd quadrant), it can
|
|
|
|
|
// be expressed as rotation by PI
|
|
|
|
|
aScale = basegfx::absolute(aScale);
|
2006-11-28 10:03:58 +00:00
|
|
|
fRotate += F_PI;
|
2006-10-19 09:40:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(basegfx::fTools::more(aScale.getX(), 0.0) && basegfx::fTools::more(aScale.getY(), 0.0))
|
|
|
|
|
{
|
2007-02-13 07:16:41 +00:00
|
|
|
// prepare everything that is not sheared and mirrored
|
2007-12-04 14:21:39 +00:00
|
|
|
Font aFont(primitive2d::getVclFontFromFontAttributes(
|
2007-11-19 09:21:42 +00:00
|
|
|
rTextCandidate.getFontAttributes(), aScale.getX(), aScale.getY(), fRotate, *mpOutputDevice));
|
2007-07-09 12:19:09 +00:00
|
|
|
|
2007-02-13 07:16:41 +00:00
|
|
|
// handle additional font attributes
|
2007-02-21 08:00:34 +00:00
|
|
|
const primitive2d::TextDecoratedPortionPrimitive2D* pTCPP =
|
|
|
|
|
dynamic_cast<const primitive2d::TextDecoratedPortionPrimitive2D*>( &rTextCandidate );
|
2007-07-09 12:19:09 +00:00
|
|
|
|
2007-02-13 07:16:41 +00:00
|
|
|
if( pTCPP != NULL )
|
|
|
|
|
{
|
|
|
|
|
// set Underline attribute
|
|
|
|
|
FontUnderline eFontUnderline = UNDERLINE_NONE;
|
|
|
|
|
switch( pTCPP->getFontUnderline() )
|
|
|
|
|
{
|
|
|
|
|
default:
|
|
|
|
|
DBG_WARNING1( "DrawingLayer: Unknown underline attribute (%d)!", pTCPP->getFontUnderline() );
|
|
|
|
|
// fall through
|
|
|
|
|
case primitive2d::FONT_UNDERLINE_NONE: eFontUnderline = UNDERLINE_NONE; break;
|
|
|
|
|
case primitive2d::FONT_UNDERLINE_SINGLE: eFontUnderline = UNDERLINE_SINGLE; break;
|
|
|
|
|
case primitive2d::FONT_UNDERLINE_DOUBLE: eFontUnderline = UNDERLINE_DOUBLE; break;
|
|
|
|
|
case primitive2d::FONT_UNDERLINE_DOTTED: eFontUnderline = UNDERLINE_DOTTED; break;
|
|
|
|
|
case primitive2d::FONT_UNDERLINE_DASH: eFontUnderline = UNDERLINE_DASH; break;
|
|
|
|
|
case primitive2d::FONT_UNDERLINE_LONGDASH: eFontUnderline = UNDERLINE_LONGDASH; break;
|
|
|
|
|
case primitive2d::FONT_UNDERLINE_DASHDOT: eFontUnderline = UNDERLINE_DASHDOT; break;
|
|
|
|
|
case primitive2d::FONT_UNDERLINE_DASHDOTDOT:eFontUnderline = UNDERLINE_DASHDOTDOT; break;
|
|
|
|
|
case primitive2d::FONT_UNDERLINE_SMALLWAVE: eFontUnderline = UNDERLINE_SMALLWAVE; break;
|
|
|
|
|
case primitive2d::FONT_UNDERLINE_WAVE: eFontUnderline = UNDERLINE_WAVE; break;
|
|
|
|
|
case primitive2d::FONT_UNDERLINE_DOUBLEWAVE:eFontUnderline = UNDERLINE_DOUBLEWAVE; break;
|
|
|
|
|
case primitive2d::FONT_UNDERLINE_BOLD: eFontUnderline = UNDERLINE_BOLD; break;
|
|
|
|
|
case primitive2d::FONT_UNDERLINE_BOLDDOTTED:eFontUnderline = UNDERLINE_BOLDDOTTED; break;
|
|
|
|
|
case primitive2d::FONT_UNDERLINE_BOLDDASH: eFontUnderline = UNDERLINE_BOLDDASH; break;
|
|
|
|
|
case primitive2d::FONT_UNDERLINE_BOLDLONGDASH:eFontUnderline = UNDERLINE_LONGDASH; break;
|
|
|
|
|
case primitive2d::FONT_UNDERLINE_BOLDDASHDOT:eFontUnderline = UNDERLINE_BOLDDASHDOT; break;
|
|
|
|
|
case primitive2d::FONT_UNDERLINE_BOLDDASHDOTDOT:eFontUnderline = UNDERLINE_BOLDDASHDOT; break;
|
|
|
|
|
case primitive2d::FONT_UNDERLINE_BOLDWAVE: eFontUnderline = UNDERLINE_BOLDWAVE; break;
|
|
|
|
|
}
|
2006-10-19 09:40:02 +00:00
|
|
|
|
2007-02-13 07:16:41 +00:00
|
|
|
if( eFontUnderline != UNDERLINE_NONE )
|
|
|
|
|
{
|
|
|
|
|
aFont.SetUnderline( eFontUnderline );
|
|
|
|
|
if( pTCPP->getWordLineMode() )
|
|
|
|
|
aFont.SetWordLineMode( true );
|
|
|
|
|
//TODO: ??? if( pTCPP->getUnderlineAbove() )
|
|
|
|
|
// aFont.SetUnderlineAbove( true );
|
|
|
|
|
}
|
2006-10-19 09:40:02 +00:00
|
|
|
|
2007-02-13 07:16:41 +00:00
|
|
|
// set Strikeout attribute
|
|
|
|
|
FontStrikeout eFontStrikeout = STRIKEOUT_NONE;
|
|
|
|
|
switch( pTCPP->getFontStrikeout() )
|
|
|
|
|
{
|
|
|
|
|
default:
|
|
|
|
|
DBG_WARNING1( "DrawingLayer: Unknown strikeout attribute (%d)!", pTCPP->getFontUnderline() );
|
|
|
|
|
// fall through
|
|
|
|
|
case primitive2d::FONT_STRIKEOUT_NONE: eFontStrikeout = STRIKEOUT_NONE; break;
|
|
|
|
|
case primitive2d::FONT_STRIKEOUT_SINGLE: eFontStrikeout = STRIKEOUT_SINGLE; break;
|
|
|
|
|
case primitive2d::FONT_STRIKEOUT_DOUBLE: eFontStrikeout = STRIKEOUT_DOUBLE; break;
|
|
|
|
|
case primitive2d::FONT_STRIKEOUT_BOLD: eFontStrikeout = STRIKEOUT_BOLD; break;
|
|
|
|
|
case primitive2d::FONT_STRIKEOUT_SLASH: eFontStrikeout = STRIKEOUT_SLASH; break;
|
|
|
|
|
case primitive2d::FONT_STRIKEOUT_X: eFontStrikeout = STRIKEOUT_X; break;
|
|
|
|
|
}
|
2006-10-19 09:40:02 +00:00
|
|
|
|
2007-02-13 07:16:41 +00:00
|
|
|
if( eFontStrikeout != STRIKEOUT_NONE )
|
|
|
|
|
aFont.SetStrikeout( eFontStrikeout );
|
|
|
|
|
|
|
|
|
|
// set EmphasisMark attribute
|
|
|
|
|
FontEmphasisMark eFontEmphasisMark = EMPHASISMARK_NONE;
|
|
|
|
|
switch( pTCPP->getFontEmphasisMark() )
|
2006-10-19 09:40:02 +00:00
|
|
|
{
|
2007-02-13 07:16:41 +00:00
|
|
|
default:
|
|
|
|
|
DBG_WARNING1( "DrawingLayer: Unknown EmphasisMark style (%d)!", pTCPP->getFontEmphasisMark() );
|
|
|
|
|
// fall through
|
|
|
|
|
case primitive2d::FONT_EMPHASISMARK_NONE: eFontEmphasisMark = EMPHASISMARK_NONE; break;
|
|
|
|
|
case primitive2d::FONT_EMPHASISMARK_DOT: eFontEmphasisMark = EMPHASISMARK_DOT; break;
|
|
|
|
|
case primitive2d::FONT_EMPHASISMARK_CIRCLE: eFontEmphasisMark = EMPHASISMARK_CIRCLE; break;
|
|
|
|
|
case primitive2d::FONT_EMPHASISMARK_DISC: eFontEmphasisMark = EMPHASISMARK_DISC; break;
|
|
|
|
|
case primitive2d::FONT_EMPHASISMARK_ACCENT: eFontEmphasisMark = EMPHASISMARK_ACCENT; break;
|
2006-10-19 09:40:02 +00:00
|
|
|
}
|
2007-02-13 07:16:41 +00:00
|
|
|
|
|
|
|
|
if( eFontEmphasisMark != EMPHASISMARK_NONE )
|
|
|
|
|
{
|
|
|
|
|
DBG_ASSERT( (pTCPP->getEmphasisMarkAbove() != pTCPP->getEmphasisMarkBelow()),
|
|
|
|
|
"DrawingLayer: Bad EmphasisMark position!" );
|
|
|
|
|
if( pTCPP->getEmphasisMarkAbove() )
|
|
|
|
|
eFontEmphasisMark |= EMPHASISMARK_POS_ABOVE;
|
|
|
|
|
else
|
|
|
|
|
eFontEmphasisMark |= EMPHASISMARK_POS_BELOW;
|
|
|
|
|
aFont.SetEmphasisMark( eFontEmphasisMark );
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// set Relief attribute
|
|
|
|
|
FontRelief eFontRelief = RELIEF_NONE;
|
|
|
|
|
switch( pTCPP->getFontRelief() )
|
|
|
|
|
{
|
|
|
|
|
default:
|
|
|
|
|
DBG_WARNING1( "DrawingLayer: Unknown Relief style (%d)!", pTCPP->getFontRelief() );
|
|
|
|
|
// fall through
|
|
|
|
|
case primitive2d::FONT_RELIEF_NONE: eFontRelief = RELIEF_NONE; break;
|
|
|
|
|
case primitive2d::FONT_RELIEF_EMBOSSED: eFontRelief = RELIEF_EMBOSSED; break;
|
|
|
|
|
case primitive2d::FONT_RELIEF_ENGRAVED: eFontRelief = RELIEF_ENGRAVED; break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if( eFontRelief != RELIEF_NONE )
|
|
|
|
|
aFont.SetRelief( eFontRelief );
|
|
|
|
|
|
|
|
|
|
// set Shadow attribute
|
|
|
|
|
if( pTCPP->getShadow() )
|
|
|
|
|
aFont.SetShadow( true );
|
2006-10-19 09:40:02 +00:00
|
|
|
}
|
|
|
|
|
|
2007-07-09 12:19:09 +00:00
|
|
|
// create transformed integer DXArray in view coordinate system
|
|
|
|
|
::std::vector< sal_Int32 > aTransformedDXArray;
|
2007-02-13 07:16:41 +00:00
|
|
|
|
2007-07-09 12:19:09 +00:00
|
|
|
if(rTextCandidate.getDXArray().size())
|
2007-02-13 07:16:41 +00:00
|
|
|
{
|
2007-07-09 12:19:09 +00:00
|
|
|
aTransformedDXArray.reserve(rTextCandidate.getDXArray().size());
|
|
|
|
|
const basegfx::B2DVector aPixelVector(aLocalTransform * basegfx::B2DVector(1.0, 0.0));
|
|
|
|
|
const double fPixelVectorLength(aPixelVector.getLength());
|
|
|
|
|
|
|
|
|
|
for(::std::vector< double >::const_iterator aStart(rTextCandidate.getDXArray().begin()); aStart != rTextCandidate.getDXArray().end(); aStart++)
|
|
|
|
|
{
|
|
|
|
|
aTransformedDXArray.push_back(basegfx::fround((*aStart) * fPixelVectorLength));
|
|
|
|
|
}
|
2007-02-13 07:16:41 +00:00
|
|
|
}
|
|
|
|
|
|
2007-10-01 08:14:08 +00:00
|
|
|
// set parameters and paint text snippet
|
2007-07-09 12:19:09 +00:00
|
|
|
const basegfx::BColor aRGBFontColor(maBColorModifierStack.getModifiedColor(rTextCandidate.getFontColor()));
|
|
|
|
|
const basegfx::B2DPoint aPoint(aLocalTransform * basegfx::B2DPoint(0.0, 0.0));
|
|
|
|
|
const Point aStartPoint(basegfx::fround(aPoint.getX()), basegfx::fround(aPoint.getY()));
|
2007-10-02 15:55:00 +00:00
|
|
|
const sal_uInt32 nOldLayoutMode(mpOutputDevice->GetLayoutMode());
|
2007-10-01 08:14:08 +00:00
|
|
|
|
2007-10-02 15:55:00 +00:00
|
|
|
if(rTextCandidate.getFontAttributes().getRTL())
|
|
|
|
|
{
|
|
|
|
|
sal_uInt32 nRTLLayoutMode(nOldLayoutMode & ~(TEXT_LAYOUT_COMPLEX_DISABLED|TEXT_LAYOUT_BIDI_STRONG));
|
|
|
|
|
nRTLLayoutMode |= TEXT_LAYOUT_BIDI_RTL|TEXT_LAYOUT_TEXTORIGIN_LEFT;
|
|
|
|
|
mpOutputDevice->SetLayoutMode(nRTLLayoutMode);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
mpOutputDevice->SetFont(aFont);
|
2007-10-01 08:14:08 +00:00
|
|
|
mpOutputDevice->SetTextColor(Color(aRGBFontColor));
|
2007-10-02 15:55:00 +00:00
|
|
|
|
2007-10-01 08:14:08 +00:00
|
|
|
mpOutputDevice->DrawTextArray(
|
|
|
|
|
aStartPoint,
|
|
|
|
|
rTextCandidate.getText(),
|
|
|
|
|
aTransformedDXArray.size() ? &(aTransformedDXArray[0]) : NULL,
|
|
|
|
|
rTextCandidate.getTextPosition(),
|
|
|
|
|
rTextCandidate.getTextLength());
|
|
|
|
|
|
2007-10-02 15:55:00 +00:00
|
|
|
if(rTextCandidate.getFontAttributes().getRTL())
|
|
|
|
|
{
|
|
|
|
|
mpOutputDevice->SetLayoutMode(nOldLayoutMode);
|
|
|
|
|
}
|
|
|
|
|
|
2007-07-09 12:19:09 +00:00
|
|
|
bPrimitiveAccepted = true;
|
|
|
|
|
}
|
2006-10-19 09:40:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(!bPrimitiveAccepted)
|
|
|
|
|
{
|
|
|
|
|
// let break down
|
|
|
|
|
process(rTextCandidate.get2DDecomposition(getViewInformation2D()));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// direct draw of hairline
|
|
|
|
|
void VclProcessor2D::RenderPolygonHairlinePrimitive2D(const primitive2d::PolygonHairlinePrimitive2D& rPolygonCandidate)
|
|
|
|
|
{
|
|
|
|
|
const basegfx::BColor aHairlineColor(maBColorModifierStack.getModifiedColor(rPolygonCandidate.getBColor()));
|
|
|
|
|
mpOutputDevice->SetLineColor(Color(aHairlineColor));
|
|
|
|
|
mpOutputDevice->SetFillColor();
|
|
|
|
|
|
|
|
|
|
basegfx::B2DPolygon aLocalPolygon(rPolygonCandidate.getB2DPolygon());
|
|
|
|
|
aLocalPolygon.transform(maCurrentTransformation);
|
2007-12-13 15:43:09 +00:00
|
|
|
mpOutputDevice->DrawPolyLine(aLocalPolygon, 0.0);
|
2006-10-19 09:40:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// direct draw of transformed BitmapEx primitive
|
|
|
|
|
void VclProcessor2D::RenderBitmapPrimitive2D(const primitive2d::BitmapPrimitive2D& rBitmapCandidate)
|
|
|
|
|
{
|
2006-11-28 10:03:58 +00:00
|
|
|
// create local transform
|
2006-10-19 09:40:02 +00:00
|
|
|
basegfx::B2DHomMatrix aLocalTransform(maCurrentTransformation * rBitmapCandidate.getTransform());
|
|
|
|
|
BitmapEx aBitmapEx(rBitmapCandidate.getBitmapEx());
|
|
|
|
|
bool bPainted(false);
|
|
|
|
|
|
|
|
|
|
if(maBColorModifierStack.count())
|
|
|
|
|
{
|
|
|
|
|
aBitmapEx = impModifyBitmapEx(maBColorModifierStack, aBitmapEx);
|
|
|
|
|
|
|
|
|
|
if(aBitmapEx.IsEmpty())
|
|
|
|
|
{
|
|
|
|
|
// color gets completely replaced, get it
|
|
|
|
|
const basegfx::BColor aModifiedColor(maBColorModifierStack.getModifiedColor(basegfx::BColor()));
|
|
|
|
|
basegfx::B2DPolygon aPolygon(basegfx::tools::createPolygonFromRect(basegfx::B2DRange(0.0, 0.0, 1.0, 1.0)));
|
|
|
|
|
aPolygon.transform(aLocalTransform);
|
|
|
|
|
|
|
|
|
|
mpOutputDevice->SetFillColor(Color(aModifiedColor));
|
|
|
|
|
mpOutputDevice->SetLineColor();
|
2007-04-17 09:02:28 +00:00
|
|
|
mpOutputDevice->DrawPolygon(aPolygon);
|
2006-10-19 09:40:02 +00:00
|
|
|
|
|
|
|
|
bPainted = true;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(!bPainted)
|
|
|
|
|
{
|
|
|
|
|
static bool bForceUseOfOwnTransformer(false);
|
|
|
|
|
static bool bUseGraphicManager(true);
|
|
|
|
|
|
2006-11-28 10:03:58 +00:00
|
|
|
// decompose matrix to check for shear, rotate and mirroring
|
|
|
|
|
basegfx::B2DVector aScale, aTranslate;
|
|
|
|
|
double fRotate, fShearX;
|
|
|
|
|
aLocalTransform.decompose(aScale, aTranslate, fRotate, fShearX);
|
|
|
|
|
|
2006-10-19 09:40:02 +00:00
|
|
|
if(!bForceUseOfOwnTransformer && basegfx::fTools::equalZero(fShearX))
|
|
|
|
|
{
|
2006-11-28 10:03:58 +00:00
|
|
|
if(!bUseGraphicManager && basegfx::fTools::equalZero(fRotate))
|
2006-10-19 09:40:02 +00:00
|
|
|
{
|
|
|
|
|
RenderBitmapPrimitive2D_BitmapEx(*mpOutputDevice, aBitmapEx, aLocalTransform);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
RenderBitmapPrimitive2D_GraphicManager(*mpOutputDevice, aBitmapEx, aLocalTransform);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if(!aBitmapEx.IsTransparent() && (!basegfx::fTools::equalZero(fShearX) || !basegfx::fTools::equalZero(fRotate)))
|
|
|
|
|
{
|
|
|
|
|
// parts will be uncovered, extend aBitmapEx with a mask bitmap
|
|
|
|
|
const Bitmap aContent(aBitmapEx.GetBitmap());
|
|
|
|
|
aBitmapEx = BitmapEx(aContent, Bitmap(aContent.GetSizePixel(), 1));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
RenderBitmapPrimitive2D_self(*mpOutputDevice, aBitmapEx, aLocalTransform);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void VclProcessor2D::RenderFillBitmapPrimitive2D(const primitive2d::FillBitmapPrimitive2D& rFillBitmapCandidate)
|
|
|
|
|
{
|
|
|
|
|
const attribute::FillBitmapAttribute& rFillBitmapAttribute(rFillBitmapCandidate.getFillBitmap());
|
|
|
|
|
bool bPrimitiveAccepted(false);
|
|
|
|
|
|
|
|
|
|
if(rFillBitmapAttribute.getTiling())
|
|
|
|
|
{
|
|
|
|
|
// decompose matrix to check for shear, rotate and mirroring
|
|
|
|
|
basegfx::B2DHomMatrix aLocalTransform(maCurrentTransformation * rFillBitmapCandidate.getTransformation());
|
|
|
|
|
basegfx::B2DVector aScale, aTranslate;
|
|
|
|
|
double fRotate, fShearX;
|
|
|
|
|
aLocalTransform.decompose(aScale, aTranslate, fRotate, fShearX);
|
|
|
|
|
|
|
|
|
|
if(basegfx::fTools::equalZero(fRotate) && basegfx::fTools::equalZero(fShearX))
|
|
|
|
|
{
|
|
|
|
|
// no shear or rotate, draw direct in pixel coordinates
|
|
|
|
|
bPrimitiveAccepted = true;
|
|
|
|
|
BitmapEx aBitmapEx(rFillBitmapAttribute.getBitmap());
|
|
|
|
|
bool bPainted(false);
|
|
|
|
|
|
|
|
|
|
if(maBColorModifierStack.count())
|
|
|
|
|
{
|
|
|
|
|
aBitmapEx = impModifyBitmapEx(maBColorModifierStack, aBitmapEx);
|
|
|
|
|
|
|
|
|
|
if(aBitmapEx.IsEmpty())
|
|
|
|
|
{
|
|
|
|
|
// color gets completely replaced, get it
|
|
|
|
|
const basegfx::BColor aModifiedColor(maBColorModifierStack.getModifiedColor(basegfx::BColor()));
|
|
|
|
|
basegfx::B2DPolygon aPolygon(basegfx::tools::createPolygonFromRect(basegfx::B2DRange(0.0, 0.0, 1.0, 1.0)));
|
|
|
|
|
aPolygon.transform(aLocalTransform);
|
|
|
|
|
|
|
|
|
|
mpOutputDevice->SetFillColor(Color(aModifiedColor));
|
|
|
|
|
mpOutputDevice->SetLineColor();
|
2007-04-17 09:02:28 +00:00
|
|
|
mpOutputDevice->DrawPolygon(aPolygon);
|
2006-10-19 09:40:02 +00:00
|
|
|
|
|
|
|
|
bPainted = true;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(!bPainted)
|
|
|
|
|
{
|
|
|
|
|
const basegfx::B2DPoint aObjTopLeft(aTranslate.getX(), aTranslate.getY());
|
|
|
|
|
const basegfx::B2DPoint aObjBottomRight(aTranslate.getX() + aScale.getX(), aTranslate.getY() + aScale.getY());
|
|
|
|
|
const Point aObjTL(mpOutputDevice->LogicToPixel(Point((sal_Int32)aObjTopLeft.getX(), (sal_Int32)aObjTopLeft.getY())));
|
|
|
|
|
const Point aObjBR(mpOutputDevice->LogicToPixel(Point((sal_Int32)aObjBottomRight.getX(), (sal_Int32)aObjBottomRight.getY())));
|
|
|
|
|
|
|
|
|
|
const basegfx::B2DPoint aBmpTopLeft(aLocalTransform * rFillBitmapAttribute.getTopLeft());
|
|
|
|
|
const basegfx::B2DPoint aBmpBottomRight(aLocalTransform * basegfx::B2DPoint(rFillBitmapAttribute.getTopLeft() + rFillBitmapAttribute.getSize()));
|
|
|
|
|
const Point aBmpTL(mpOutputDevice->LogicToPixel(Point((sal_Int32)aBmpTopLeft.getX(), (sal_Int32)aBmpTopLeft.getY())));
|
|
|
|
|
const Point aBmpBR(mpOutputDevice->LogicToPixel(Point((sal_Int32)aBmpBottomRight.getX(), (sal_Int32)aBmpBottomRight.getY())));
|
|
|
|
|
|
|
|
|
|
sal_Int32 nOWidth(aObjBR.X() - aObjTL.X());
|
|
|
|
|
sal_Int32 nOHeight(aObjBR.Y() - aObjTL.Y());
|
|
|
|
|
|
|
|
|
|
if(nOWidth < 0L)
|
|
|
|
|
{
|
|
|
|
|
nOWidth = 1L;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(nOHeight < 0L)
|
|
|
|
|
{
|
|
|
|
|
nOHeight = 1L;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
sal_Int32 nBWidth(aBmpBR.X() - aBmpTL.X());
|
|
|
|
|
sal_Int32 nBHeight(aBmpBR.Y() - aBmpTL.Y());
|
|
|
|
|
|
|
|
|
|
if(nBWidth < 0L)
|
|
|
|
|
{
|
|
|
|
|
nBWidth = 1L;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(nBHeight < 0L)
|
|
|
|
|
{
|
|
|
|
|
nBHeight = 1L;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
sal_Int32 nBLeft(aBmpTL.X());
|
|
|
|
|
sal_Int32 nBTop(aBmpTL.Y());
|
|
|
|
|
|
|
|
|
|
if(nBLeft > aObjTL.X())
|
|
|
|
|
{
|
|
|
|
|
nBLeft -= ((nBLeft / nBWidth) + 1L) * nBWidth;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(nBLeft + nBWidth <= aObjTL.X())
|
|
|
|
|
{
|
|
|
|
|
nBLeft -= (nBLeft / nBWidth) * nBWidth;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(nBTop > aObjTL.Y())
|
|
|
|
|
{
|
|
|
|
|
nBTop -= ((nBTop / nBHeight) + 1L) * nBHeight;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(nBTop + nBHeight <= aObjTL.Y())
|
|
|
|
|
{
|
|
|
|
|
nBTop -= (nBTop / nBHeight) * nBHeight;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// nBWidth, nBHeight is the pixel size of the neede bitmap. To not need to scale it
|
|
|
|
|
// in vcl many times, create a size-optimized version
|
|
|
|
|
const Size aNeededBitmapSizePixel(nBWidth, nBHeight);
|
|
|
|
|
|
|
|
|
|
if(aNeededBitmapSizePixel != aBitmapEx.GetSizePixel())
|
|
|
|
|
{
|
|
|
|
|
aBitmapEx.Scale(aNeededBitmapSizePixel);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// prepare OutDev
|
|
|
|
|
const Point aEmptyPoint(0, 0);
|
|
|
|
|
const Rectangle aVisiblePixel(aEmptyPoint, mpOutputDevice->GetOutputSizePixel());
|
|
|
|
|
const bool bWasEnabled(mpOutputDevice->IsMapModeEnabled());
|
|
|
|
|
mpOutputDevice->EnableMapMode(false);
|
|
|
|
|
|
|
|
|
|
for(sal_Int32 nXPos(nBLeft); nXPos < aObjTL.X() + nOWidth; nXPos += nBWidth)
|
|
|
|
|
{
|
|
|
|
|
for(sal_Int32 nYPos(nBTop); nYPos < aObjTL.Y() + nOHeight; nYPos += nBHeight)
|
|
|
|
|
{
|
|
|
|
|
const Rectangle aOutRectPixel(Point(nXPos, nYPos), aNeededBitmapSizePixel);
|
|
|
|
|
|
|
|
|
|
if(aOutRectPixel.IsOver(aVisiblePixel))
|
|
|
|
|
{
|
|
|
|
|
mpOutputDevice->DrawBitmapEx(aOutRectPixel.TopLeft(), aBitmapEx);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// restore OutDev
|
|
|
|
|
mpOutputDevice->EnableMapMode(bWasEnabled);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(!bPrimitiveAccepted)
|
|
|
|
|
{
|
|
|
|
|
// do not accept, use decomposition
|
|
|
|
|
process(rFillBitmapCandidate.get2DDecomposition(getViewInformation2D()));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// direct draw of gradient
|
|
|
|
|
void VclProcessor2D::RenderPolyPolygonGradientPrimitive2D(const primitive2d::PolyPolygonGradientPrimitive2D& rPolygonCandidate)
|
|
|
|
|
{
|
|
|
|
|
const attribute::FillGradientAttribute& rGradient(rPolygonCandidate.getFillGradient());
|
|
|
|
|
basegfx::BColor aStartColor(maBColorModifierStack.getModifiedColor(rGradient.getStartColor()));
|
|
|
|
|
basegfx::BColor aEndColor(maBColorModifierStack.getModifiedColor(rGradient.getEndColor()));
|
|
|
|
|
basegfx::B2DPolyPolygon aLocalPolyPolygon(rPolygonCandidate.getB2DPolyPolygon());
|
|
|
|
|
aLocalPolyPolygon.transform(maCurrentTransformation);
|
|
|
|
|
|
|
|
|
|
if(aStartColor == aEndColor)
|
|
|
|
|
{
|
|
|
|
|
// no gradient at all, draw as polygon
|
|
|
|
|
mpOutputDevice->SetLineColor();
|
|
|
|
|
mpOutputDevice->SetFillColor(Color(aStartColor));
|
|
|
|
|
mpOutputDevice->DrawPolyPolygon(aLocalPolyPolygon);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
impDrawGradientToOutDev(
|
|
|
|
|
*mpOutputDevice, aLocalPolyPolygon, rGradient.getStyle(), rGradient.getSteps(),
|
|
|
|
|
aStartColor, aEndColor, rGradient.getBorder(),
|
|
|
|
|
-rGradient.getAngle(), rGradient.getOffsetX(), rGradient.getOffsetY(), false);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// 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);
|
2007-04-17 09:02:28 +00:00
|
|
|
mpOutputDevice->DrawPolyPolygon(aLocalPolyPolygon);
|
2007-12-03 12:54:35 +00:00
|
|
|
|
2007-12-13 15:43:09 +00:00
|
|
|
if(mnPolygonStrokePrimitive2D && getOptionsDrawinglayer().IsAntiAliasing())
|
|
|
|
|
{
|
|
|
|
|
// 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);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2007-12-03 12:54:35 +00:00
|
|
|
static bool bTestPolygonClipping(false);
|
|
|
|
|
if(bTestPolygonClipping)
|
|
|
|
|
{
|
|
|
|
|
static bool bInside(true);
|
|
|
|
|
static bool bFilled(false);
|
|
|
|
|
static bool bLine(false);
|
|
|
|
|
|
|
|
|
|
basegfx::B2DRange aRange(aLocalPolyPolygon.getB2DRange());
|
|
|
|
|
aRange.grow(aRange.getWidth() * -0.1);
|
|
|
|
|
|
|
|
|
|
if(bFilled)
|
|
|
|
|
{
|
|
|
|
|
basegfx::B2DPolyPolygon aFilledClipped(basegfx::tools::clipPolyPolygonOnRange(aLocalPolyPolygon, aRange, bInside, false));
|
|
|
|
|
basegfx::BColor aRand(rand() / 32767.0, rand() / 32767.0, rand() / 32767.0);
|
|
|
|
|
mpOutputDevice->SetFillColor(Color(aRand));
|
|
|
|
|
mpOutputDevice->SetLineColor();
|
|
|
|
|
mpOutputDevice->DrawPolyPolygon(aFilledClipped);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(bLine)
|
|
|
|
|
{
|
|
|
|
|
basegfx::B2DPolyPolygon aLineClipped(basegfx::tools::clipPolyPolygonOnRange(aLocalPolyPolygon, aRange, bInside, true));
|
|
|
|
|
basegfx::BColor aRand(rand() / 32767.0, rand() / 32767.0, rand() / 32767.0);
|
|
|
|
|
mpOutputDevice->SetFillColor();
|
|
|
|
|
mpOutputDevice->SetLineColor(Color(aRand));
|
|
|
|
|
|
|
|
|
|
for(sal_uInt32 a(0); a < aLineClipped.count(); a++)
|
|
|
|
|
{
|
2007-12-13 15:43:09 +00:00
|
|
|
mpOutputDevice->DrawPolyLine(aLineClipped.getB2DPolygon(a), 0.0);
|
2007-12-03 12:54:35 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2006-10-19 09:40:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// direct draw of MetaFile
|
|
|
|
|
void VclProcessor2D::RenderMetafilePrimitive2D(const primitive2d::MetafilePrimitive2D& rMetaCandidate)
|
|
|
|
|
{
|
|
|
|
|
// decompose matrix to check for shear, rotate and mirroring
|
|
|
|
|
basegfx::B2DHomMatrix aLocalTransform(maCurrentTransformation * rMetaCandidate.getTransform());
|
|
|
|
|
basegfx::B2DVector aScale, aTranslate;
|
|
|
|
|
double fRotate, fShearX;
|
|
|
|
|
aLocalTransform.decompose(aScale, aTranslate, fRotate, fShearX);
|
|
|
|
|
|
|
|
|
|
// get BoundRect
|
|
|
|
|
basegfx::B2DRange aOutlineRange(rMetaCandidate.getB2DRange(getViewInformation2D()));
|
|
|
|
|
aOutlineRange.transform(maCurrentTransformation);
|
2008-05-14 08:22:09 +00:00
|
|
|
|
|
|
|
|
// Due to the integer MapModes used from VCL aind inside MetaFiles errors of up to three
|
|
|
|
|
// pixels in size may happen. As long as there is no better way (e.g. convert the MetaFile
|
|
|
|
|
// to primitives) it is necessary to reduce maximum pixel size by 1 in X and Y and to use
|
|
|
|
|
// the inner pixel bounds accordingly (ceil resp. floor). This will also be done for logic
|
|
|
|
|
// units e.g. when creating a new MetaFile, but since much huger value ranges are used
|
|
|
|
|
// there typically will be okay for this compromize.
|
|
|
|
|
Rectangle aDestRectView(
|
|
|
|
|
(sal_Int32)ceil(aOutlineRange.getMinX()), (sal_Int32)ceil(aOutlineRange.getMinY()),
|
|
|
|
|
(sal_Int32)floor(aOutlineRange.getMaxX()), (sal_Int32)floor(aOutlineRange.getMaxY()));
|
|
|
|
|
|
|
|
|
|
if(aDestRectView.Right() > aDestRectView.Left())
|
|
|
|
|
{
|
|
|
|
|
aDestRectView.Right()--;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(aDestRectView.Bottom() > aDestRectView.Top())
|
|
|
|
|
{
|
|
|
|
|
aDestRectView.Bottom()--;
|
|
|
|
|
}
|
2006-10-19 09:40:02 +00:00
|
|
|
|
|
|
|
|
// get metafile (copy it)
|
|
|
|
|
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();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// rotation
|
|
|
|
|
if(!basegfx::fTools::equalZero(fRotate))
|
|
|
|
|
{
|
|
|
|
|
double fRotation((fRotate / F_PI180) * -10.0);
|
|
|
|
|
aMetaFile.Rotate((sal_uInt16)(fRotation));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// paint it
|
|
|
|
|
aMetaFile.WindStart();
|
|
|
|
|
aMetaFile.Play(mpOutputDevice, aDestRectView.TopLeft(), aDestRectView.GetSize());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// mask group. Force output to VDev and create mask from given mask
|
2007-07-27 08:04:00 +00:00
|
|
|
void VclProcessor2D::RenderMaskPrimitive2DPixel(const primitive2d::MaskPrimitive2D& rMaskCandidate)
|
2006-10-19 09:40:02 +00:00
|
|
|
{
|
|
|
|
|
if(rMaskCandidate.getChildren().hasElements())
|
|
|
|
|
{
|
|
|
|
|
basegfx::B2DPolyPolygon aMask(rMaskCandidate.getMask());
|
|
|
|
|
|
2007-03-06 11:36:13 +00:00
|
|
|
if(aMask.count())
|
2006-10-19 09:40:02 +00:00
|
|
|
{
|
2007-03-06 11:36:13 +00:00
|
|
|
aMask.transform(maCurrentTransformation);
|
2007-07-09 12:19:09 +00:00
|
|
|
const basegfx::B2DRange aRange(basegfx::tools::getRange(aMask));
|
2008-10-17 08:40:10 +00:00
|
|
|
impBufferDevice aBufferDevice(*mpOutputDevice, aRange, true);
|
2006-10-19 09:40:02 +00:00
|
|
|
|
2007-07-09 12:19:09 +00:00
|
|
|
if(aBufferDevice.isVisible())
|
2007-03-06 11:36:13 +00:00
|
|
|
{
|
2007-07-09 12:19:09 +00:00
|
|
|
// remember last OutDev and set to content
|
|
|
|
|
OutputDevice* pLastOutputDevice = mpOutputDevice;
|
|
|
|
|
mpOutputDevice = &aBufferDevice.getContent();
|
2007-03-06 11:36:13 +00:00
|
|
|
|
2007-07-09 12:19:09 +00:00
|
|
|
// paint to it
|
|
|
|
|
process(rMaskCandidate.getChildren());
|
2007-03-06 11:36:13 +00:00
|
|
|
|
2007-07-09 12:19:09 +00:00
|
|
|
// back to old OutDev
|
|
|
|
|
mpOutputDevice = pLastOutputDevice;
|
2007-03-06 11:36:13 +00:00
|
|
|
|
2007-07-09 12:19:09 +00:00
|
|
|
// draw mask
|
2007-12-13 15:43:09 +00:00
|
|
|
if(getOptionsDrawinglayer().IsAntiAliasing())
|
|
|
|
|
{
|
|
|
|
|
// with AA, use 8bit AlphaMask to get nice borders
|
|
|
|
|
VirtualDevice& rAlpha = aBufferDevice.getAlpha();
|
|
|
|
|
rAlpha.SetLineColor();
|
|
|
|
|
rAlpha.SetFillColor(COL_BLACK);
|
|
|
|
|
rAlpha.DrawPolyPolygon(aMask);
|
|
|
|
|
|
|
|
|
|
// dump buffer to outdev
|
|
|
|
|
aBufferDevice.paint();
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
// No AA, use 1bit mask
|
|
|
|
|
VirtualDevice& rMask = aBufferDevice.getMask();
|
|
|
|
|
rMask.SetLineColor();
|
|
|
|
|
rMask.SetFillColor(COL_BLACK);
|
|
|
|
|
rMask.DrawPolyPolygon(aMask);
|
|
|
|
|
|
|
|
|
|
// dump buffer to outdev
|
|
|
|
|
aBufferDevice.paint();
|
|
|
|
|
}
|
2007-03-06 11:36:13 +00:00
|
|
|
}
|
2006-10-19 09:40:02 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// modified color group. Force output to unified color.
|
|
|
|
|
void VclProcessor2D::RenderModifiedColorPrimitive2D(const primitive2d::ModifiedColorPrimitive2D& rModifiedCandidate)
|
|
|
|
|
{
|
|
|
|
|
if(rModifiedCandidate.getChildren().hasElements())
|
|
|
|
|
{
|
|
|
|
|
maBColorModifierStack.push(rModifiedCandidate.getColorModifier());
|
|
|
|
|
process(rModifiedCandidate.getChildren());
|
|
|
|
|
maBColorModifierStack.pop();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// sub-transparence group. Draw to VDev first.
|
|
|
|
|
void VclProcessor2D::RenderAlphaPrimitive2D(const primitive2d::AlphaPrimitive2D& rTransCandidate)
|
|
|
|
|
{
|
|
|
|
|
if(rTransCandidate.getChildren().hasElements())
|
|
|
|
|
{
|
|
|
|
|
basegfx::B2DRange aRange(primitive2d::getB2DRangeFromPrimitive2DSequence(rTransCandidate.getChildren(), getViewInformation2D()));
|
|
|
|
|
aRange.transform(maCurrentTransformation);
|
2008-10-17 08:40:10 +00:00
|
|
|
impBufferDevice aBufferDevice(*mpOutputDevice, aRange, true);
|
2006-10-19 09:40:02 +00:00
|
|
|
|
|
|
|
|
if(aBufferDevice.isVisible())
|
|
|
|
|
{
|
|
|
|
|
// remember last OutDev and set to content
|
|
|
|
|
OutputDevice* pLastOutputDevice = mpOutputDevice;
|
|
|
|
|
mpOutputDevice = &aBufferDevice.getContent();
|
|
|
|
|
|
|
|
|
|
// paint content to it
|
|
|
|
|
process(rTransCandidate.getChildren());
|
|
|
|
|
|
|
|
|
|
// set to mask
|
|
|
|
|
mpOutputDevice = &aBufferDevice.getAlpha();
|
|
|
|
|
|
|
|
|
|
// when painting alpha masks, reset the color stack
|
|
|
|
|
basegfx::BColorModifierStack aLastBColorModifierStack(maBColorModifierStack);
|
|
|
|
|
maBColorModifierStack = basegfx::BColorModifierStack();
|
|
|
|
|
|
2007-12-13 15:43:09 +00:00
|
|
|
// paint mask to it (always with alpha intensities, evtl. with AA)
|
2006-10-19 09:40:02 +00:00
|
|
|
process(rTransCandidate.getAlpha());
|
|
|
|
|
|
|
|
|
|
// back to old color stack
|
|
|
|
|
maBColorModifierStack = aLastBColorModifierStack;
|
|
|
|
|
|
|
|
|
|
// back to old OutDev
|
|
|
|
|
mpOutputDevice = pLastOutputDevice;
|
|
|
|
|
|
|
|
|
|
// dump buffer to outdev
|
|
|
|
|
aBufferDevice.paint();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// transform group.
|
|
|
|
|
void VclProcessor2D::RenderTransformPrimitive2D(const primitive2d::TransformPrimitive2D& rTransformCandidate)
|
|
|
|
|
{
|
2007-09-20 08:51:46 +00:00
|
|
|
// remember current transformation and ViewInformation
|
|
|
|
|
const basegfx::B2DHomMatrix aLastCurrentTransformation(maCurrentTransformation);
|
|
|
|
|
const geometry::ViewInformation2D aLastViewInformation2D(getViewInformation2D());
|
2006-10-19 09:40:02 +00:00
|
|
|
|
2007-09-20 08:51:46 +00:00
|
|
|
// create new transformations for CurrentTransformation
|
|
|
|
|
// and for local ViewInformation2D
|
2006-10-19 09:40:02 +00:00
|
|
|
maCurrentTransformation = maCurrentTransformation * rTransformCandidate.getTransformation();
|
2008-06-10 08:29:56 +00:00
|
|
|
const geometry::ViewInformation2D aViewInformation2D(
|
2008-06-24 14:31:09 +00:00
|
|
|
getViewInformation2D().getObjectTransformation() * rTransformCandidate.getTransformation(),
|
|
|
|
|
getViewInformation2D().getViewTransformation(),
|
2007-09-20 08:51:46 +00:00
|
|
|
getViewInformation2D().getViewport(),
|
2008-02-07 12:42:32 +00:00
|
|
|
getViewInformation2D().getVisualizedPage(),
|
|
|
|
|
getViewInformation2D().getViewTime(),
|
|
|
|
|
getViewInformation2D().getExtendedInformationSequence());
|
2008-06-10 08:29:56 +00:00
|
|
|
updateViewInformation(aViewInformation2D);
|
2006-10-19 09:40:02 +00:00
|
|
|
|
2007-09-20 08:51:46 +00:00
|
|
|
// proccess content
|
2006-10-19 09:40:02 +00:00
|
|
|
process(rTransformCandidate.getChildren());
|
|
|
|
|
|
|
|
|
|
// restore transformations
|
|
|
|
|
maCurrentTransformation = aLastCurrentTransformation;
|
2008-06-10 08:29:56 +00:00
|
|
|
updateViewInformation(aLastViewInformation2D);
|
2006-10-19 09:40:02 +00:00
|
|
|
}
|
|
|
|
|
|
2008-02-07 12:42:32 +00:00
|
|
|
// new XDrawPage for ViewInformation2D
|
|
|
|
|
void VclProcessor2D::RenderPagePreviewPrimitive2D(const primitive2d::PagePreviewPrimitive2D& rPagePreviewCandidate)
|
|
|
|
|
{
|
|
|
|
|
// remember current transformation and ViewInformation
|
|
|
|
|
const geometry::ViewInformation2D aLastViewInformation2D(getViewInformation2D());
|
|
|
|
|
|
|
|
|
|
// create new local ViewInformation2D
|
2008-06-10 08:29:56 +00:00
|
|
|
const geometry::ViewInformation2D aViewInformation2D(
|
2008-06-24 14:31:09 +00:00
|
|
|
getViewInformation2D().getObjectTransformation(),
|
2008-02-07 12:42:32 +00:00
|
|
|
getViewInformation2D().getViewTransformation(),
|
|
|
|
|
getViewInformation2D().getViewport(),
|
|
|
|
|
rPagePreviewCandidate.getXDrawPage(),
|
|
|
|
|
getViewInformation2D().getViewTime(),
|
|
|
|
|
getViewInformation2D().getExtendedInformationSequence());
|
2008-06-10 08:29:56 +00:00
|
|
|
updateViewInformation(aViewInformation2D);
|
2008-02-07 12:42:32 +00:00
|
|
|
|
|
|
|
|
// proccess decomposed content
|
|
|
|
|
process(rPagePreviewCandidate.get2DDecomposition(getViewInformation2D()));
|
|
|
|
|
|
|
|
|
|
// restore transformations
|
2008-06-10 08:29:56 +00:00
|
|
|
updateViewInformation(aLastViewInformation2D);
|
2008-02-07 12:42:32 +00:00
|
|
|
}
|
|
|
|
|
|
2006-10-19 09:40:02 +00:00
|
|
|
// marker
|
2007-01-25 17:21:36 +00:00
|
|
|
void VclProcessor2D::RenderMarkerArrayPrimitive2D(const primitive2d::MarkerArrayPrimitive2D& rMarkArrayCandidate)
|
2006-10-19 09:40:02 +00:00
|
|
|
{
|
2007-07-27 08:04:00 +00:00
|
|
|
static bool bCheckCompleteMarkerDecompose(false);
|
|
|
|
|
if(bCheckCompleteMarkerDecompose)
|
|
|
|
|
{
|
|
|
|
|
process(rMarkArrayCandidate.get2DDecomposition(getViewInformation2D()));
|
|
|
|
|
return;
|
|
|
|
|
}
|
2006-10-19 09:40:02 +00:00
|
|
|
|
2007-07-27 08:04:00 +00:00
|
|
|
switch(rMarkArrayCandidate.getStyle())
|
2006-10-19 09:40:02 +00:00
|
|
|
{
|
2007-07-27 08:04:00 +00:00
|
|
|
default :
|
2007-01-25 17:21:36 +00:00
|
|
|
{
|
2007-07-27 08:04:00 +00:00
|
|
|
// not handled/unknown MarkerArrayPrimitive2D, use decomposition
|
|
|
|
|
process(rMarkArrayCandidate.get2DDecomposition(getViewInformation2D()));
|
|
|
|
|
break;
|
2007-01-25 17:21:36 +00:00
|
|
|
}
|
2007-07-27 08:04:00 +00:00
|
|
|
case primitive2d::MARKERSTYLE2D_CROSS :
|
|
|
|
|
case primitive2d::MARKERSTYLE2D_GLUEPOINT :
|
2006-10-19 09:40:02 +00:00
|
|
|
{
|
2007-07-27 08:04:00 +00:00
|
|
|
// directly supported markers
|
|
|
|
|
const std::vector< basegfx::B2DPoint >& rPositions = rMarkArrayCandidate.getPositions();
|
|
|
|
|
const basegfx::BColor aRGBColor(maBColorModifierStack.getModifiedColor(rMarkArrayCandidate.getRGBColor()));
|
|
|
|
|
const Color aVCLColor(aRGBColor);
|
2008-05-14 08:22:09 +00:00
|
|
|
const basegfx::B2DHomMatrix aTransObjectToDiscrete(mpOutputDevice->GetViewTransformation() * maCurrentTransformation);
|
2006-10-19 09:40:02 +00:00
|
|
|
|
2007-07-27 08:04:00 +00:00
|
|
|
for(std::vector< basegfx::B2DPoint >::const_iterator aIter(rPositions.begin()); aIter != rPositions.end(); aIter++)
|
2006-10-19 09:40:02 +00:00
|
|
|
{
|
2008-05-14 08:22:09 +00:00
|
|
|
const basegfx::B2DPoint aDiscretePosition(aTransObjectToDiscrete * (*aIter));
|
|
|
|
|
const Point aPos(basegfx::fround(aDiscretePosition.getX()), basegfx::fround(aDiscretePosition.getY()));
|
2007-07-27 08:04:00 +00:00
|
|
|
|
|
|
|
|
switch(rMarkArrayCandidate.getStyle())
|
2007-01-25 17:21:36 +00:00
|
|
|
{
|
2007-07-27 08:04:00 +00:00
|
|
|
default :
|
|
|
|
|
{
|
|
|
|
|
// this would be an error, ther cases here need to be consistent with the initially
|
|
|
|
|
// accepted ones
|
|
|
|
|
OSL_ENSURE(false, "Inconsistent RenderMarkerArrayPrimitive2D implementation (!)");
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case primitive2d::MARKERSTYLE2D_CROSS :
|
|
|
|
|
{
|
|
|
|
|
mpOutputDevice->DrawPixel(aPos, aVCLColor);
|
|
|
|
|
mpOutputDevice->DrawPixel(Point(aPos.X() - 1L, aPos.Y()), aVCLColor);
|
|
|
|
|
mpOutputDevice->DrawPixel(Point(aPos.X() + 1L, aPos.Y()), aVCLColor);
|
|
|
|
|
mpOutputDevice->DrawPixel(Point(aPos.X(), aPos.Y() - 1L), aVCLColor);
|
|
|
|
|
mpOutputDevice->DrawPixel(Point(aPos.X(), aPos.Y() + 1L), aVCLColor);
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case primitive2d::MARKERSTYLE2D_GLUEPOINT :
|
|
|
|
|
{
|
|
|
|
|
// backpen
|
|
|
|
|
mpOutputDevice->SetLineColor(aVCLColor);
|
|
|
|
|
mpOutputDevice->DrawLine(aPos + Point(-2, -3), aPos + Point(+3, +2));
|
|
|
|
|
mpOutputDevice->DrawLine(aPos + Point(-3, -2), aPos + Point(+2, +3));
|
|
|
|
|
mpOutputDevice->DrawLine(aPos + Point(-3, +2), aPos + Point(+2, -3));
|
|
|
|
|
mpOutputDevice->DrawLine(aPos + Point(-2, +3), aPos + Point(+3, -2));
|
|
|
|
|
|
|
|
|
|
// frontpen (hard coded)
|
|
|
|
|
const basegfx::BColor aRGBFrontColor(maBColorModifierStack.getModifiedColor(Color(COL_LIGHTBLUE).getBColor()));
|
|
|
|
|
mpOutputDevice->SetLineColor(Color(aRGBFrontColor));
|
|
|
|
|
mpOutputDevice->DrawLine(aPos + Point(-2, -2), aPos + Point(+2, +2));
|
|
|
|
|
mpOutputDevice->DrawLine(aPos + Point(-2, +2), aPos + Point(+2, -2));
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
}
|
2007-01-25 17:21:36 +00:00
|
|
|
}
|
2007-07-27 08:04:00 +00:00
|
|
|
|
2006-10-19 09:40:02 +00:00
|
|
|
}
|
2007-01-25 17:21:36 +00:00
|
|
|
|
2007-07-27 08:04:00 +00:00
|
|
|
break;
|
2006-10-19 09:40:02 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2007-07-27 08:04:00 +00:00
|
|
|
// point
|
|
|
|
|
void VclProcessor2D::RenderPointArrayPrimitive2D(const primitive2d::PointArrayPrimitive2D& rPointArrayCandidate)
|
|
|
|
|
{
|
|
|
|
|
const std::vector< basegfx::B2DPoint >& rPositions = rPointArrayCandidate.getPositions();
|
|
|
|
|
const basegfx::BColor aRGBColor(maBColorModifierStack.getModifiedColor(rPointArrayCandidate.getRGBColor()));
|
|
|
|
|
const Color aVCLColor(aRGBColor);
|
|
|
|
|
|
|
|
|
|
for(std::vector< basegfx::B2DPoint >::const_iterator aIter(rPositions.begin()); aIter != rPositions.end(); aIter++)
|
|
|
|
|
{
|
|
|
|
|
const basegfx::B2DPoint aViewPosition(maCurrentTransformation * (*aIter));
|
|
|
|
|
const Point aPos(basegfx::fround(aViewPosition.getX()), basegfx::fround(aViewPosition.getY()));
|
|
|
|
|
|
|
|
|
|
mpOutputDevice->DrawPixel(aPos, aVCLColor);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2007-11-20 09:20:18 +00:00
|
|
|
void VclProcessor2D::RenderPolygonStrokePrimitive2D(const primitive2d::PolygonStrokePrimitive2D& rPolygonStrokeCandidate)
|
|
|
|
|
{
|
|
|
|
|
const attribute::LineAttribute& rLineAttribute = rPolygonStrokeCandidate.getLineAttribute();
|
|
|
|
|
const double fLineWidth(rLineAttribute.getWidth());
|
|
|
|
|
bool bDone(false);
|
|
|
|
|
|
|
|
|
|
if(basegfx::fTools::more(fLineWidth, 0.0))
|
|
|
|
|
{
|
|
|
|
|
const basegfx::B2DVector aDiscreteUnit(maCurrentTransformation * basegfx::B2DVector(1.0, 1.0));
|
|
|
|
|
const double fDiscreteLineWidth((fLineWidth * aDiscreteUnit.getX() + fLineWidth * aDiscreteUnit.getY()) * 0.5);
|
|
|
|
|
|
|
|
|
|
if(basegfx::fTools::lessOrEqual(fDiscreteLineWidth, 2.5))
|
|
|
|
|
{
|
|
|
|
|
// force to hairline
|
|
|
|
|
const attribute::StrokeAttribute& rStrokeAttribute = rPolygonStrokeCandidate.getStrokeAttribute();
|
|
|
|
|
const basegfx::BColor aHairlineColor(maBColorModifierStack.getModifiedColor(rLineAttribute.getColor()));
|
|
|
|
|
basegfx::B2DPolyPolygon aHairlinePolyPolygon;
|
|
|
|
|
|
|
|
|
|
mpOutputDevice->SetLineColor(Color(aHairlineColor));
|
|
|
|
|
mpOutputDevice->SetFillColor();
|
|
|
|
|
|
|
|
|
|
if(0.0 == rStrokeAttribute.getFullDotDashLen())
|
|
|
|
|
{
|
|
|
|
|
// no line dashing, just copy
|
|
|
|
|
aHairlinePolyPolygon.append(rPolygonStrokeCandidate.getB2DPolygon());
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
// else apply LineStyle
|
|
|
|
|
basegfx::tools::applyLineDashing(rPolygonStrokeCandidate.getB2DPolygon(),
|
|
|
|
|
rStrokeAttribute.getDotDashArray(),
|
|
|
|
|
&aHairlinePolyPolygon, 0, rStrokeAttribute.getFullDotDashLen());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const sal_uInt32 nCount(aHairlinePolyPolygon.count());
|
|
|
|
|
|
|
|
|
|
if(nCount)
|
|
|
|
|
{
|
|
|
|
|
aHairlinePolyPolygon.transform(maCurrentTransformation);
|
|
|
|
|
|
2008-04-16 03:59:59 +00:00
|
|
|
if(basegfx::fTools::more(fDiscreteLineWidth, 1.5))
|
2007-11-20 09:20:18 +00:00
|
|
|
{
|
2008-04-16 03:59:59 +00:00
|
|
|
// line width is in range ]1.5 .. 2.5], use four hairlines
|
|
|
|
|
// drawn in a square
|
|
|
|
|
basegfx::B2DHomMatrix aMat;
|
2007-11-20 09:20:18 +00:00
|
|
|
|
2008-04-16 03:59:59 +00:00
|
|
|
for(sal_uInt32 a(0); a < nCount; a++)
|
2007-11-20 09:20:18 +00:00
|
|
|
{
|
2008-04-16 03:59:59 +00:00
|
|
|
basegfx::B2DPolygon aCandidate(aHairlinePolyPolygon.getB2DPolygon(a));
|
|
|
|
|
mpOutputDevice->DrawPolyLine(aCandidate, 0.0);
|
2007-11-20 09:20:18 +00:00
|
|
|
|
2008-04-16 03:59:59 +00:00
|
|
|
aMat.set(0, 2, 1.0);
|
|
|
|
|
aMat.set(1, 2, 0.0);
|
2007-11-20 09:20:18 +00:00
|
|
|
aCandidate.transform(aMat);
|
2008-04-16 03:59:59 +00:00
|
|
|
|
2007-11-20 09:20:18 +00:00
|
|
|
mpOutputDevice->DrawPolyLine(aCandidate, 0.0);
|
|
|
|
|
|
2008-04-16 03:59:59 +00:00
|
|
|
aMat.set(0, 2, 0.0);
|
|
|
|
|
aMat.set(1, 2, 1.0);
|
2007-11-20 09:20:18 +00:00
|
|
|
aCandidate.transform(aMat);
|
2008-04-16 03:59:59 +00:00
|
|
|
|
2007-11-20 09:20:18 +00:00
|
|
|
mpOutputDevice->DrawPolyLine(aCandidate, 0.0);
|
|
|
|
|
|
2008-04-16 03:59:59 +00:00
|
|
|
aMat.set(0, 2, -1.0);
|
|
|
|
|
aMat.set(1, 2, 0.0);
|
2007-11-20 09:20:18 +00:00
|
|
|
aCandidate.transform(aMat);
|
2008-04-16 03:59:59 +00:00
|
|
|
|
|
|
|
|
mpOutputDevice->DrawPolyLine(aCandidate, 0.0);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
for(sal_uInt32 a(0); a < nCount; a++)
|
|
|
|
|
{
|
|
|
|
|
// draw the basic hairline polygon
|
|
|
|
|
const basegfx::B2DPolygon aCandidate(aHairlinePolyPolygon.getB2DPolygon(a));
|
2007-11-20 09:20:18 +00:00
|
|
|
mpOutputDevice->DrawPolyLine(aCandidate, 0.0);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bDone = true;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(!bDone)
|
|
|
|
|
{
|
|
|
|
|
// line width is big enough for standard filled polygon visualisation or zero
|
|
|
|
|
process(rPolygonStrokeCandidate.get2DDecomposition(getViewInformation2D()));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2007-12-12 12:23:40 +00:00
|
|
|
void VclProcessor2D::adaptLineToFillDrawMode() const
|
|
|
|
|
{
|
|
|
|
|
const sal_uInt32 nOriginalDrawMode(mpOutputDevice->GetDrawMode());
|
|
|
|
|
|
|
|
|
|
if(nOriginalDrawMode & (DRAWMODE_BLACKLINE|DRAWMODE_GRAYLINE|DRAWMODE_GHOSTEDLINE|DRAWMODE_WHITELINE|DRAWMODE_SETTINGSLINE))
|
|
|
|
|
{
|
|
|
|
|
sal_uInt32 nAdaptedDrawMode(nOriginalDrawMode);
|
|
|
|
|
|
|
|
|
|
if(nOriginalDrawMode & DRAWMODE_BLACKLINE)
|
|
|
|
|
{
|
|
|
|
|
nAdaptedDrawMode |= DRAWMODE_BLACKFILL;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
nAdaptedDrawMode &= ~DRAWMODE_BLACKFILL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(nOriginalDrawMode & DRAWMODE_GRAYLINE)
|
|
|
|
|
{
|
|
|
|
|
nAdaptedDrawMode |= DRAWMODE_GRAYFILL;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
nAdaptedDrawMode &= ~DRAWMODE_GRAYFILL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(nOriginalDrawMode & DRAWMODE_GHOSTEDLINE)
|
|
|
|
|
{
|
|
|
|
|
nAdaptedDrawMode |= DRAWMODE_GHOSTEDFILL;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
nAdaptedDrawMode &= ~DRAWMODE_GHOSTEDFILL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(nOriginalDrawMode & DRAWMODE_WHITELINE)
|
|
|
|
|
{
|
|
|
|
|
nAdaptedDrawMode |= DRAWMODE_WHITEFILL;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
nAdaptedDrawMode &= ~DRAWMODE_WHITEFILL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(nOriginalDrawMode & DRAWMODE_SETTINGSLINE)
|
|
|
|
|
{
|
|
|
|
|
nAdaptedDrawMode |= DRAWMODE_SETTINGSFILL;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
nAdaptedDrawMode &= ~DRAWMODE_SETTINGSFILL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
mpOutputDevice->SetDrawMode(nAdaptedDrawMode);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void VclProcessor2D::adaptTextToFillDrawMode() const
|
|
|
|
|
{
|
|
|
|
|
const sal_uInt32 nOriginalDrawMode(mpOutputDevice->GetDrawMode());
|
|
|
|
|
if(nOriginalDrawMode & (DRAWMODE_BLACKTEXT|DRAWMODE_GRAYTEXT|DRAWMODE_GHOSTEDTEXT|DRAWMODE_WHITETEXT|DRAWMODE_SETTINGSTEXT))
|
|
|
|
|
{
|
|
|
|
|
sal_uInt32 nAdaptedDrawMode(nOriginalDrawMode);
|
|
|
|
|
|
|
|
|
|
if(nOriginalDrawMode & DRAWMODE_BLACKTEXT)
|
|
|
|
|
{
|
|
|
|
|
nAdaptedDrawMode |= DRAWMODE_BLACKFILL;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
nAdaptedDrawMode &= ~DRAWMODE_BLACKFILL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(nOriginalDrawMode & DRAWMODE_GRAYTEXT)
|
|
|
|
|
{
|
|
|
|
|
nAdaptedDrawMode |= DRAWMODE_GRAYFILL;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
nAdaptedDrawMode &= ~DRAWMODE_GRAYFILL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(nOriginalDrawMode & DRAWMODE_GHOSTEDTEXT)
|
|
|
|
|
{
|
|
|
|
|
nAdaptedDrawMode |= DRAWMODE_GHOSTEDFILL;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
nAdaptedDrawMode &= ~DRAWMODE_GHOSTEDFILL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(nOriginalDrawMode & DRAWMODE_WHITETEXT)
|
|
|
|
|
{
|
|
|
|
|
nAdaptedDrawMode |= DRAWMODE_WHITEFILL;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
nAdaptedDrawMode &= ~DRAWMODE_WHITEFILL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if(nOriginalDrawMode & DRAWMODE_SETTINGSTEXT)
|
|
|
|
|
{
|
|
|
|
|
nAdaptedDrawMode |= DRAWMODE_SETTINGSFILL;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
nAdaptedDrawMode &= ~DRAWMODE_SETTINGSFILL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
mpOutputDevice->SetDrawMode(nAdaptedDrawMode);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2007-10-15 15:11:08 +00:00
|
|
|
basegfx::B2DPoint VclProcessor2D::PositionAndSizeControl(const primitive2d::ControlPrimitive2D& rControlPrimitive2D)
|
|
|
|
|
{
|
|
|
|
|
// prepare output for given device
|
|
|
|
|
Reference< XGraphics > xGraphics(mpOutputDevice->CreateUnoGraphics());
|
|
|
|
|
Reference< XView > xControlView(rControlPrimitive2D.getXControl(), UNO_QUERY_THROW);
|
|
|
|
|
xControlView->setGraphics(xGraphics);
|
|
|
|
|
|
|
|
|
|
// set position and size (in pixel)
|
2007-10-16 14:46:52 +00:00
|
|
|
const basegfx::B2DHomMatrix aObjectToPixel(maCurrentTransformation * rControlPrimitive2D.getTransform());
|
2007-10-15 15:11:08 +00:00
|
|
|
const basegfx::B2DPoint aTopLeftPixel(aObjectToPixel * basegfx::B2DPoint(0.0, 0.0));
|
|
|
|
|
Reference< XWindow > xControlWindow(rControlPrimitive2D.getXControl(), UNO_QUERY);
|
|
|
|
|
|
|
|
|
|
if(xControlWindow.is())
|
|
|
|
|
{
|
|
|
|
|
const basegfx::B2DPoint aBottomRightPixel(aObjectToPixel * basegfx::B2DPoint(1.0, 1.0));
|
|
|
|
|
|
|
|
|
|
xControlWindow->setPosSize(
|
|
|
|
|
basegfx::fround(aTopLeftPixel.getX()), basegfx::fround(aTopLeftPixel.getY()),
|
|
|
|
|
basegfx::fround(aBottomRightPixel.getX() - aTopLeftPixel.getX()),
|
|
|
|
|
basegfx::fround(aBottomRightPixel.getY() - aTopLeftPixel.getY()),
|
|
|
|
|
POSSIZE);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return aTopLeftPixel;
|
|
|
|
|
}
|
|
|
|
|
|
2006-10-19 09:40:02 +00:00
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
2007-07-09 12:19:09 +00:00
|
|
|
// process support
|
2006-10-19 09:40:02 +00:00
|
|
|
|
|
|
|
|
VclProcessor2D::VclProcessor2D(
|
|
|
|
|
const geometry::ViewInformation2D& rViewInformation,
|
|
|
|
|
OutputDevice& rOutDev)
|
|
|
|
|
: BaseProcessor2D(rViewInformation),
|
2007-03-06 11:36:13 +00:00
|
|
|
mpOutputDevice(&rOutDev),
|
|
|
|
|
maBColorModifierStack(),
|
2007-12-12 12:23:40 +00:00
|
|
|
maCurrentTransformation(),
|
2007-12-13 15:43:09 +00:00
|
|
|
maDrawinglayerOpt(),
|
|
|
|
|
mnPolygonStrokePrimitive2D(0)
|
2006-10-19 09:40:02 +00:00
|
|
|
{
|
2007-10-02 15:55:00 +00:00
|
|
|
// set digit language, derived from SvtCTLOptions to have the correct
|
|
|
|
|
// number display for arabic/hindi numerals
|
|
|
|
|
const SvtCTLOptions aSvtCTLOptions;
|
|
|
|
|
LanguageType eLang(LANGUAGE_SYSTEM);
|
|
|
|
|
|
|
|
|
|
if(SvtCTLOptions::NUMERALS_HINDI == aSvtCTLOptions.GetCTLTextNumerals())
|
|
|
|
|
{
|
|
|
|
|
eLang = LANGUAGE_ARABIC;
|
|
|
|
|
}
|
|
|
|
|
else if(SvtCTLOptions::NUMERALS_ARABIC == aSvtCTLOptions.GetCTLTextNumerals())
|
|
|
|
|
{
|
|
|
|
|
eLang = LANGUAGE_ENGLISH;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
eLang = (LanguageType)Application::GetSettings().GetLanguage();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
rOutDev.SetDigitLanguage(eLang);
|
2007-07-09 12:19:09 +00:00
|
|
|
}
|
2006-10-19 09:40:02 +00:00
|
|
|
|
2007-07-09 12:19:09 +00:00
|
|
|
VclProcessor2D::~VclProcessor2D()
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
} // end of namespace processor2d
|
|
|
|
|
} // end of namespace drawinglayer
|
2007-03-06 11:36:13 +00:00
|
|
|
|
2006-10-19 09:40:02 +00:00
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
// eof
|
