From 90708571c7606047ee307d706336cc0de588943d Mon Sep 17 00:00:00 2001 From: Ivo Hinkelmann Date: Thu, 3 Aug 2006 11:38:09 +0000 Subject: INTEGRATION: CWS impress100 (1.1.2); FILE ADDED 2006/07/27 14:22:10 sj 1.1.2.1: #i56656# graphictools.hxx has been moved from svtools to vcl --- vcl/source/gdi/graphictools.cxx | 767 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 767 insertions(+) create mode 100644 vcl/source/gdi/graphictools.cxx (limited to 'vcl/source/gdi/graphictools.cxx') diff --git a/vcl/source/gdi/graphictools.cxx b/vcl/source/gdi/graphictools.cxx new file mode 100644 index 000000000000..35b70ff4d2c2 --- /dev/null +++ b/vcl/source/gdi/graphictools.cxx @@ -0,0 +1,767 @@ +/************************************************************************* + * + * OpenOffice.org - a multi-platform office productivity suite + * + * $RCSfile: graphictools.cxx,v $ + * + * $Revision: 1.2 $ + * + * last change: $Author: ihi $ $Date: 2006-08-03 12:38:09 $ + * + * 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 + * + ************************************************************************/ + +#ifndef _VCOMPAT_HXX +#include +#endif + +#include "graphictools.hxx" + +static ::rtl::OString polyToString( const Polygon& rPoly ) +{ + ::rtl::OString aStr; + USHORT nVertex; + for(nVertex=0; nVertex( rPoly[nVertex].getX() ) ); + aStr += ","; + aStr += ::rtl::OString::valueOf( static_cast< double >( rPoly[nVertex].getY() ) ); + aStr += ") "; + } + + return aStr; +} + +static ::rtl::OString polyPolyToString( const PolyPolygon& rPolyPoly ) +{ + ::rtl::OString aStr; + USHORT nPoly; + for(nPoly=0; nPoly(getTransparency()) ); + aStr += " width: "; + aStr += ::rtl::OString::valueOf( static_cast< double >(getStrokeWidth()) ); + aStr += " cap: "; + switch( getCapType() ) + { + case capButt: + aStr += "butt"; + break; + + case capRound: + aStr += "round"; + break; + + case capSquare: + aStr += "square"; + break; + + default: + DBG_ERROR( "SvtGraphicStroke::toString missing cap type"); + break; + } + aStr += " join: "; + switch( getJoinType() ) + { + case joinMiter: + aStr += "miter"; + break; + + case joinRound: + aStr += "round"; + break; + + case joinBevel: + aStr += "bevel"; + break; + + case joinNone: + aStr += "none"; + break; + + default: + DBG_ERROR( "SvtGraphicStroke::toString missing join type"); + break; + } + aStr += " "; + + if( maStartArrow.Count() ) + { + aStr += "start: "; + aStr += polyPolyToString( maStartArrow ); + aStr += " "; + } + + if( maEndArrow.Count() ) + { + aStr += "end: "; + aStr += polyPolyToString( maEndArrow ); + aStr += " "; + } + + aStr += dashToString( maDashArray ); + + return aStr; +} + +void SvtGraphicStroke::setPath( const Polygon& rPoly ) +{ + maPath = rPoly; +} + +void SvtGraphicStroke::setStartArrow( const PolyPolygon& rPoly ) +{ + maStartArrow = rPoly; +} + +void SvtGraphicStroke::setEndArrow( const PolyPolygon& rPoly ) +{ + maEndArrow = rPoly; +} + +void SvtGraphicStroke::setTransparency( double fTrans ) +{ + mfTransparency = fTrans; +} + +void SvtGraphicStroke::setStrokeWidth( double fWidth ) +{ + mfStrokeWidth = fWidth; +} + +void SvtGraphicStroke::setCapType( CapType eType ) +{ + maCapType = eType; +} + +void SvtGraphicStroke::setJoinType( JoinType eType ) +{ + maJoinType = eType; +} + +void SvtGraphicStroke::setMiterLimit( double fMiterLimit ) +{ + mfMiterLimit = fMiterLimit; +} + +void SvtGraphicStroke::setDashArray( const DashArray& rDashArray ) +{ + maDashArray = rDashArray; +} + +SvStream& operator<<( SvStream& rOStm, const SvtGraphicStroke& rClass ) +{ + VersionCompat aCompat( rOStm, STREAM_WRITE, 1 ); + + rClass.maPath.Write( rOStm ); + rClass.maStartArrow.Write( rOStm ); + rClass.maEndArrow.Write( rOStm ); + rOStm << rClass.mfTransparency; + rOStm << rClass.mfStrokeWidth; + UINT16 nTmp = sal::static_int_cast( rClass.maCapType ); + rOStm << nTmp; + nTmp = sal::static_int_cast( rClass.maJoinType ); + rOStm << nTmp; + rOStm << rClass.mfMiterLimit; + + rOStm << static_cast(rClass.maDashArray.size()); + size_t i; + for(i=0; i>( SvStream& rIStm, SvtGraphicStroke& rClass ) +{ + VersionCompat aCompat( rIStm, STREAM_READ ); + + rClass.maPath.Read( rIStm ); + rClass.maStartArrow.Read( rIStm ); + rClass.maEndArrow.Read( rIStm ); + rIStm >> rClass.mfTransparency; + rIStm >> rClass.mfStrokeWidth; + UINT16 nTmp; + rIStm >> nTmp; + rClass.maCapType = SvtGraphicStroke::CapType(nTmp); + rIStm >> nTmp; + rClass.maJoinType = SvtGraphicStroke::JoinType(nTmp); + rIStm >> rClass.mfMiterLimit; + + sal_uInt32 nSize; + rIStm >> nSize; + rClass.maDashArray.resize(nSize); + size_t i; + for(i=0; i> rClass.maDashArray[i]; + + return rIStm; +} + + +///////////////////////////////////////////////////////////////////////////// + +SvtGraphicFill::SvtGraphicFill() : + maPath(), + maFillColor( COL_BLACK ), + mfTransparency(), + maFillRule(), + maFillType(), + maFillTransform(), + maHatchType(), + maHatchColor( COL_BLACK ), + maGradientType(), + maGradient1stColor( COL_BLACK ), + maGradient2ndColor( COL_BLACK ), + maGradientStepCount( gradientStepsInfinite ), + maFillGraphic() +{ +} + +SvtGraphicFill::SvtGraphicFill( const PolyPolygon& rPath, + Color aFillColor, + double fTransparency, + FillRule aFillRule, + FillType aFillType, + const Transform& aFillTransform, + bool bTiling, + HatchType aHatchType, + Color aHatchColor, + GradientType aGradientType, + Color aGradient1stColor, + Color aGradient2ndColor, + int aGradientStepCount, + const Graphic& aFillGraphic ) : + maPath( rPath ), + maFillColor( aFillColor ), + mfTransparency( fTransparency ), + maFillRule( aFillRule ), + maFillType( aFillType ), + maFillTransform( aFillTransform ), + mbTiling( bTiling ), + maHatchType( aHatchType ), + maHatchColor( aHatchColor ), + maGradientType( aGradientType ), + maGradient1stColor( aGradient1stColor ), + maGradient2ndColor( aGradient2ndColor ), + maGradientStepCount( aGradientStepCount ), + maFillGraphic( aFillGraphic ) +{ +} + +void SvtGraphicFill::getPath( PolyPolygon& rPath ) const +{ + rPath = maPath; +} + +Color SvtGraphicFill::getFillColor() const +{ + return maFillColor; +} + +double SvtGraphicFill::getTransparency() const +{ + return mfTransparency; +} + +SvtGraphicFill::FillRule SvtGraphicFill::getFillRule() const +{ + return maFillRule; +} + +SvtGraphicFill::FillType SvtGraphicFill::getFillType() const +{ + return maFillType; +} + +void SvtGraphicFill::getTransform( Transform& rTrans ) const +{ + rTrans = maFillTransform; +} + +bool SvtGraphicFill::IsTiling() const +{ + return mbTiling; +} + +bool SvtGraphicFill::isTiling() const +{ + return mbTiling; +} + +SvtGraphicFill::HatchType SvtGraphicFill::getHatchType() const +{ + return maHatchType; +} + +Color SvtGraphicFill::getHatchColor() const +{ + return maHatchColor; +} + +SvtGraphicFill::GradientType SvtGraphicFill::getGradientType() const +{ + return maGradientType; +} + +Color SvtGraphicFill::getGradient1stColor() const +{ + return maGradient1stColor; +} + +Color SvtGraphicFill::getGradient2ndColor() const +{ + return maGradient2ndColor; +} + +int SvtGraphicFill::getGradientStepCount() const +{ + return maGradientStepCount; +} + +void SvtGraphicFill::getGraphic( Graphic& rGraphic ) const +{ + rGraphic = maFillGraphic; +} + +::rtl::OString SvtGraphicFill::toString() const +{ + ::rtl::OString aStr; + + aStr += polyPolyToString( maPath ); + aStr += "fill"; + aStr += colorToString( getFillColor() ); + aStr += " trans: "; + aStr += ::rtl::OString::valueOf( static_cast< double >(getTransparency()) ); + aStr += " rule: "; + switch( getFillRule() ) + { + case fillNonZero: + aStr += "nonzero"; + break; + + case fillEvenOdd: + aStr += "evenodd"; + break; + + default: + DBG_ERROR( "SvtGraphicFill::toString missing fill rule"); + break; + } + aStr += " type: "; + switch( getFillType() ) + { + case fillSolid: + aStr += "solid"; + break; + + case fillGradient: + aStr += "gradient"; + break; + + case fillHatch: + aStr += "hatch"; + break; + + case fillTexture: + aStr += "bitmap"; + break; + + default: + DBG_ERROR( "SvtGraphicStroke::toString missing fill type"); + break; + } + + aStr += " transform: [ "; + int i; + for(i=0; i(maFillGraphic.GetSizeBytes()) ); + aStr += " bytes"; + } + + return aStr; +} + +void SvtGraphicFill::setPath( const PolyPolygon& rPath ) +{ + maPath = rPath; +} + +void SvtGraphicFill::setFillColor( Color aFillColor ) +{ + maFillColor = aFillColor; +} + +void SvtGraphicFill::setTransparency( double fTransparency ) +{ + mfTransparency = fTransparency; +} + +void SvtGraphicFill::setFillRule( FillRule aFillRule ) +{ + maFillRule = aFillRule; +} + +void SvtGraphicFill::setFillType( FillType aFillType ) +{ + maFillType = aFillType; +} + +void SvtGraphicFill::setTransform( const Transform& rTransform ) +{ + maFillTransform = rTransform; +} + +void SvtGraphicFill::setTiling( bool bTiling ) +{ + mbTiling = bTiling; +} + +void SvtGraphicFill::setHatchType( HatchType aHatchType ) +{ + maHatchType = aHatchType; +} + +void SvtGraphicFill::setHatchColor( Color aHatchColor ) +{ + maHatchColor = aHatchColor; +} + +void SvtGraphicFill::setGradientType( GradientType aGradType ) +{ + maGradientType = aGradType; +} + +void SvtGraphicFill::setGradient1stColor( Color aColor ) +{ + maGradient1stColor = aColor; +} + +void SvtGraphicFill::setGradient2ndColor( Color aColor ) +{ + maGradient2ndColor = aColor; +} + +void SvtGraphicFill::setGradientStepCount( int aCount ) +{ + maGradientStepCount = aCount; +} + +void SvtGraphicFill::setGraphic( const Graphic& rGraphic ) +{ + maFillGraphic = rGraphic; +} + +SvStream& operator<<( SvStream& rOStm, const SvtGraphicFill& rClass ) +{ + VersionCompat aCompat( rOStm, STREAM_WRITE, 1 ); + + rClass.maPath.Write( rOStm ); + rOStm << rClass.maFillColor; + rOStm << rClass.mfTransparency; + UINT16 nTmp = sal::static_int_cast( rClass.maFillRule ); + rOStm << nTmp; + nTmp = sal::static_int_cast( rClass.maFillType ); + rOStm << nTmp; + int i; + for(i=0; i( rClass.maHatchType ); + rOStm << nTmp; + rOStm << rClass.maHatchColor; + nTmp = sal::static_int_cast( rClass.maGradientType ); + rOStm << nTmp; + rOStm << rClass.maGradient1stColor; + rOStm << rClass.maGradient2ndColor; + rOStm << rClass.maGradientStepCount; + rOStm << rClass.maFillGraphic; + + return rOStm; +} + +SvStream& operator>>( SvStream& rIStm, SvtGraphicFill& rClass ) +{ + VersionCompat aCompat( rIStm, STREAM_READ ); + + rClass.maPath.Read( rIStm ); + rIStm >> rClass.maFillColor; + rIStm >> rClass.mfTransparency; + UINT16 nTmp; + rIStm >> nTmp; + rClass.maFillRule = SvtGraphicFill::FillRule( nTmp ); + rIStm >> nTmp; + rClass.maFillType = SvtGraphicFill::FillType( nTmp ); + int i; + for(i=0; i> rClass.maFillTransform.matrix[i]; + rIStm >> nTmp; + rClass.mbTiling = nTmp; + rIStm >> nTmp; + rClass.maHatchType = SvtGraphicFill::HatchType( nTmp ); + rIStm >> rClass.maHatchColor; + rIStm >> nTmp; + rClass.maGradientType = SvtGraphicFill::GradientType( nTmp ); + rIStm >> rClass.maGradient1stColor; + rIStm >> rClass.maGradient2ndColor; + rIStm >> rClass.maGradientStepCount; + rIStm >> rClass.maFillGraphic; + + return rIStm; +} -- cgit